From d5ca348990093d4685da19dc48b707228590b0f5 Mon Sep 17 00:00:00 2001 From: Dylan Perks Date: Sun, 8 Aug 2021 00:22:30 +0100 Subject: [PATCH 1/2] This is the August 2021 Update (v2.7.0) --- build/cache/gl.json.gz | Bin 840241 -> 840613 bytes build/cache/glcore.json.gz | Bin 470176 -> 470193 bytes build/cache/gles2.json.gz | Bin 341644 -> 342207 bytes build/cache/openxr.json.gz | Bin 53280 -> 56929 bytes build/cache/vulkan.json.gz | Bin 215967 -> 217324 bytes build/props/common.props | 18 +- .../IntelPerformanceQuery.gen.cs | 2400 ++++++++++++++--- .../IntelPerformanceQueryOverloads.gen.cs | 1028 +++---- .../IntelPerformanceQuery.gen.cs | 2400 ++++++++++++++--- .../IntelPerformanceQueryOverloads.gen.cs | 1028 +++---- .../NVTransformFeedback.gen.cs | 144 +- .../NVTransformFeedbackOverloads.gen.cs | 64 +- .../AngleTranslatedShaderSource.gen.cs | 36 +- ...ngleTranslatedShaderSourceOverloads.gen.cs | 16 +- .../IntelPerformanceQuery.gen.cs | 2400 ++++++++++++++--- .../IntelPerformanceQueryOverloads.gen.cs | 1028 +++---- .../QComExtendedGet2.gen.cs | 24 +- .../QComExtendedGet2Overloads.gen.cs | 32 +- .../FBFoveation.gen.cs | 49 + .../FBFoveationOverloads.gen.cs | 42 + .../Silk.NET.OpenXR.Extensions.LIV.csproj | 14 + .../MsftSpatialAnchorPersistence.gen.cs | 107 + ...ftSpatialAnchorPersistenceOverloads.gen.cs | 84 + .../Silk.NET.OpenXR.Extensions.UNITY.csproj | 14 + .../Enums/BlendFactorFB.gen.cs | 28 + .../CompositionLayerImageLayoutFlagsFB.gen.cs | 19 + ...ompositionLayerSecureContentFlagsFB.gen.cs | 21 + .../Enums/FoveationDynamicFB.gen.cs | 20 + .../Enums/FoveationLevelFB.gen.cs | 24 + .../Silk.NET.OpenXR/Enums/ObjectType.gen.cs | 4 + .../Silk.NET.OpenXR/Enums/Result.gen.cs | 4 + .../Enums/StructureType.gen.cs | 20 + .../SwapchainCreateFoveationFlagsFB.gen.cs | 21 + .../SwapchainStateFoveationFlagsFB.gen.cs | 17 + .../Enums/SwapchainUsageFlags.gen.cs | 2 + .../CompositionLayerAlphaBlendFB.gen.cs | 94 + .../CompositionLayerImageLayoutFB.gen.cs | 61 + .../CompositionLayerSecureContentFB.gen.cs | 61 + .../FoveationLevelProfileCreateInfoFB.gen.cs | 83 + .../FoveationProfileCreateInfoFB.gen.cs | 50 + .../Structs/FoveationProfileFB.gen.cs | 39 + ...orFromPersistedAnchorCreateInfoMSFT.gen.cs | 72 + .../SpatialAnchorPersistenceInfoMSFT.gen.cs | 72 + .../SpatialAnchorPersistenceNameMSFT.gen.cs | 28 + .../SpatialAnchorStoreConnectionMSFT.gen.cs | 39 + .../SwapchainCreateInfoFoveationFB.gen.cs | 61 + .../SwapchainImageFoveationVulkanFB.gen.cs | 83 + .../Structs/SwapchainStateFoveationFB.gen.cs | 72 + .../HuaweiInvocationMask.gen.cs | 33 + .../HuaweiSubpassShading.gen.cs | 8 +- .../HuaweiSubpassShadingOverloads.gen.cs | 4 +- .../KhrPresentWait.gen.cs | 33 + .../NVExternalMemoryRdma.gen.cs | 45 + .../NVExternalMemoryRdmaOverloads.gen.cs | 42 + .../Enums/AccessFlags2KHR.gen.cs | 4 +- .../ExternalMemoryHandleTypeFlags.gen.cs | 4 +- .../Enums/ImageUsageFlags.gen.cs | 6 +- .../Enums/MemoryPropertyFlags.gen.cs | 4 +- .../Enums/PipelineStageFlags2KHR.gen.cs | 4 +- .../Enums/StructureType.gen.cs | 14 + .../Enums/VideoCapabilitiesFlagsKHR.gen.cs | 21 - .../Enums/VideoCapabilityFlagsKHR.gen.cs | 21 + .../VideoDecodeH264FieldLayoutFlagsEXT.gen.cs | 23 - ...ideoDecodeH264PictureLayoutFlagsEXT.gen.cs | 23 + ... VideoEncodeH264CapabilityFlagsEXT.gen.cs} | 4 +- .../MemoryGetRemoteAddressInfoNV.gen.cs | 72 + ...lDeviceExternalMemoryRDMAFeaturesNV.gen.cs | 61 + ...lDeviceInvocationMaskFeaturesHUAWEI.gen.cs | 61 + .../PhysicalDevicePresentIdFeaturesKHR.gen.cs | 61 + ...hysicalDevicePresentWaitFeaturesKHR.gen.cs | 61 + ...DeviceShaderAtomicFloat2FeaturesEXT.gen.cs | 182 ++ .../PipelineCacheHeaderVersionOne.gen.cs | 77 + .../Structs/PresentIdKHR.gen.cs | 72 + .../Structs/VideoCapabilitiesKHR.gen.cs | 8 +- .../Structs/VideoDecodeH264ProfileEXT.gen.cs | 14 +- .../VideoEncodeH264CapabilitiesEXT.gen.cs | 8 +- 76 files changed, 10206 insertions(+), 2687 deletions(-) create mode 100644 src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.FB/FBFoveation.gen.cs create mode 100644 src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.FB/FBFoveationOverloads.gen.cs create mode 100644 src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.LIV/Silk.NET.OpenXR.Extensions.LIV.csproj create mode 100644 src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistence.gen.cs create mode 100644 src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistenceOverloads.gen.cs create mode 100644 src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.UNITY/Silk.NET.OpenXR.Extensions.UNITY.csproj create mode 100644 src/OpenXR/Silk.NET.OpenXR/Enums/BlendFactorFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Enums/CompositionLayerImageLayoutFlagsFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Enums/CompositionLayerSecureContentFlagsFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Enums/FoveationDynamicFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Enums/FoveationLevelFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Enums/SwapchainCreateFoveationFlagsFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Enums/SwapchainStateFoveationFlagsFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/CompositionLayerAlphaBlendFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/CompositionLayerImageLayoutFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/CompositionLayerSecureContentFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/FoveationLevelProfileCreateInfoFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/FoveationProfileCreateInfoFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/FoveationProfileFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorFromPersistedAnchorCreateInfoMSFT.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorPersistenceInfoMSFT.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorPersistenceNameMSFT.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorStoreConnectionMSFT.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/SwapchainCreateInfoFoveationFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/SwapchainImageFoveationVulkanFB.gen.cs create mode 100644 src/OpenXR/Silk.NET.OpenXR/Structs/SwapchainStateFoveationFB.gen.cs create mode 100644 src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.HUAWEI/HuaweiInvocationMask.gen.cs create mode 100644 src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.KHR/KhrPresentWait.gen.cs create mode 100644 src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVExternalMemoryRdma.gen.cs create mode 100644 src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVExternalMemoryRdmaOverloads.gen.cs delete mode 100644 src/Vulkan/Silk.NET.Vulkan/Enums/VideoCapabilitiesFlagsKHR.gen.cs create mode 100644 src/Vulkan/Silk.NET.Vulkan/Enums/VideoCapabilityFlagsKHR.gen.cs delete mode 100644 src/Vulkan/Silk.NET.Vulkan/Enums/VideoDecodeH264FieldLayoutFlagsEXT.gen.cs create mode 100644 src/Vulkan/Silk.NET.Vulkan/Enums/VideoDecodeH264PictureLayoutFlagsEXT.gen.cs rename src/Vulkan/Silk.NET.Vulkan/Enums/{VideoEncodeH264CapabilitiesFlagsEXT.gen.cs => VideoEncodeH264CapabilityFlagsEXT.gen.cs} (94%) create mode 100644 src/Vulkan/Silk.NET.Vulkan/Structs/MemoryGetRemoteAddressInfoNV.gen.cs create mode 100644 src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceExternalMemoryRDMAFeaturesNV.gen.cs create mode 100644 src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceInvocationMaskFeaturesHUAWEI.gen.cs create mode 100644 src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDevicePresentIdFeaturesKHR.gen.cs create mode 100644 src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDevicePresentWaitFeaturesKHR.gen.cs create mode 100644 src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceShaderAtomicFloat2FeaturesEXT.gen.cs create mode 100644 src/Vulkan/Silk.NET.Vulkan/Structs/PipelineCacheHeaderVersionOne.gen.cs create mode 100644 src/Vulkan/Silk.NET.Vulkan/Structs/PresentIdKHR.gen.cs diff --git a/build/cache/gl.json.gz b/build/cache/gl.json.gz index e157907efd1e9e7966bf925159f5519f07a69bec..32aaa3d052f8d003bbda76c63ca97499addfe44a 100644 GIT binary patch delta 249535 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ⅇ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

Q1-fS8FGZ$<8kjQA+d->6U5l?o~H8X9p#I3&O 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 delta 249067 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

Qx8;C(kIoy{~wv%gEwq$$EsrxW(^L1j-)Mv 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

NI59Po^(F2YHB4On;;OU>a$# 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 z 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

yELXg_a`fu>7A(}pdOfj$iq zieY>^=pBI|9ua6`^yl)Y%O1suXJwqM@$_M1k^J!$Z8AK#pG1%_oTCmvel`;IH zhV)F3_c*Mzpfz+QjDg>4Pe>%_+Hj5ng7vth{E0D%G<-k|TWkzaV1w9Wuy7im`gxmJ z+wZm*0lR&)9}X;00aP-XZ&bWN*fH$KQ}q65Ot{+nXjC#q&jX@CKmAA1g@f7&qR@OW zQ&ZgzM2<*;Qc*4;c@>WY(X2!>78?j(3=hBN$?6~Vq00+^p}-4YC=f5xwPsPk($q>|Uo9fT7!dlC{Sedw>qCK@``{nQd*uIr zAb)rK59H5I|A9QH`2Pv=od>E2k0Bz&!?QX0`=#|hE332@u{w-@Lf&x5aFk!);-TR- zZQ+8@Nkk+bgD@F~9|2!LB=~1_`18Kq%hBey+fCtFZ+n`(4uxJ5Kce-=QzwSXp(Qh_ ziM4@2EMHY@&Crdo0~kn619AIR*homp_$affvZ<~PBgFTTSP^i)X33q>^Nm}V7DvCW zgk*x?rY&~t=j-ptF*Idzs!WDK!R$dDS4XB;l%WL91p1-%R78BVj10dkn|pDdXJk5o zXk)f2LNS*8orI}rWu#&lj{`9}O8IHqeEoy{Z$WW#1B@CU{GXa)hjmcAY$L3oe9wf* zgo)P?AIvEA(iD)FQEdzNrwCZV>ZV*pXRiRtg6m{djVT`Swqc=%7Or5`$&AHOP%f*s zC1o#?o*&%5V&Py!+18)Gon3#1c?*}e^+22~ZzQFk{yL|M9C@?mNLVsfpNVb(&eqA1R1>B(`9~(!pJ>G}YZS&8ji1Z;0 z=Le(K3kAh4jU|hRQOHEQ8C_pc?b?p%#l&D#UK(s|%Sp3)ZdAy-)JaUDHcy}VMi>7><*EnNaeu@oqeI0*ghzT=u= z0$~hBN|=0sZ;$(2KrfU?3YgHJJw?kxlftM%{~r^P846F(1>q=B)l{L2$Sfb_QM93* z&=!b*Owe-BTF@&iKkR1rK>QIh1^WKhATCDgWlqo&l1CO6dZx0P(DHfqt+Q#?B%QGq@CFHHs70E=wx$JalE>F6mVfU$=y35Ap_$ITLEzxYxVb#4ZV zHFPNLb@cFFEmdEi{X#GIA2@~w_&YIbH`y|_p`)_|zpVuM(R$slTSd?47`wBz|!f0c(vVo6-_)x78djtw<16GtJKvYa>xK(tT zk2N1tft?Iwl;mYlHp0`4jhe_zga(=*aul;=gV9^I-%9%`+%gs3h zi7@D}#RwS#(gBDxKN{0WEY}lKe@ygHRwfYMU(vUP>3BjbS{{;3wy6ukYq-LvBz4H; zzi*GUi|$VTx=tXFIp-#)gO}TP!^j~0gMs&!|H~U+*f%C|dgMiKUr1bEZn_@5VqiER zQtaGTCKCe)`(??JObQ!w#a6=)2SaOF=HwlZfS0PJ98X?YpKL6{t5gDlArjjV( z&7NEM(=20i<5|vwgi&2khvqOs=TL5M+%A|Uu+f$rbQ&;=@BKOz{XYv#$D$DOe`Ja= z6`l4!?l9{$m9PJ!D&Du%Pfam;)NI=`So0s-Kv6 zaPdhJ#fc4Xl?$*wuu4h1@tD*r77hs52!f&z@}z;5GD59JT5PG7-@QRkN)Q!__l0^) zHyj<0tJ)klR?o_ZMn98^5%IgGTE&lnu}rX155`v#U^I+SCb(?{@3}v&GUBBhcG^e1 zY#~#twjI9iQ9SbCh7^Bv6dL#hAG2i(eZ8pxk-vfJF5t?@ZoChuMRN>tS;XcgREH+8 zG>tUIM6=9)EI(NtzF$A<+4$aHE?^CYcTm_KuB*K@h+vol9>SK%vBraQu21o)mSo-&mjV zP|ks>=HIboU&GIr4Ht2nK60~;gh01X$Tj|Bg2(;b#DAiQhU9ff63RbC6k$TaZ?N9= zy5KW%d{seBBGm1?Yl@tXu#lJ#G6L2o)66UTmQEylv8;w>l+(=P$M}tHJg9ea3osH3 zH%c7DYS_^3#xsI0SY=E+Dz`N2Cw(cvt}nNsIf7qRaqW$-k5|#wjVH?q1YEX$k{eOE zGf;^psUn4K2v~eojCl6CcC+jwOVE{SUhWg1-9(K2i z@!M#YEHjyqg-lu{(u1hj$@A32B=HdgTVF0lM?DUivs;<&_!;t^;3gJ9E@Lv1^kyZzC7XAvf0QC_ znYB|o!pv`lQ;*V=I+}jbF!g)^&f}6u9+)VG>y>yj1A??K+p&(Mo;YG#RSQNl3Osy_VH4Evzw# z)!D|!NBDyP`Gksv(r3MxCaagv`I#GkKCb0TtbxQEFRzugLWN`#6zO2in{x~G1y(TO zL*lV4d;R{B0*xe%sD3b~jA!2N4X$IqG9CS(zpwIYt*r6G@W{ ze?2L8VA2)amqCKGq-vrdUBTz?S~OAC#?3wkAKeQy**s{K%d0lbJ^!DuZB zVb!*A&%94Q2{}Pc6D`!AD{JW1g=`WGQv#X1&b6tYbA6Mtj;$WY4LspB5jU;<3A;bn zPR}f_72~3KmaoTn@CKe={1+j~dQTMcy7(B~_}t0(VU1Pcjm?JzeB}1qn;U1Cn=P00 zb*aB38gWoxMY8~D$0B>HkdO3)SN)8D7yS{Vgo70ApPJ zY|6mIZ(9^z&#c23@<&va&N@0nDnddDh$-*oDm%~Y6JxgJk5n4u{EG=JRXc7HDncqy zZSUYbQn`CgZX5uKUASf9Nzw&Av!vS;OCFePx+o7yTg<~T%C5WqH)K5@-pK8*#0q-$ zsdok^sNIwguk#7&f?B4qgW7*dzZv8*UyeOGuv#|P8T|(pqL9>qrfaE;{$GC6O8WzX zmV}1p)p&ePVJ_i2&jX=ybi}9|+#e_}2oNeF(CA`^i?C}U!9FGVo{$|8>6Y$j;V zMmi<``sM!zD^!`PMud=vOhn=n6)nrdv+&Men|vik*2d7rayPU6!0M4EOfp9^ZZzEq zHtQ1RaduPkSCbW#!V-~z-TJW`5GcWM#5)Ba;|(G~XPW8KphdsqRo6(<+W!Vvb}yvZ zz@HFc#P|&o81J|0XuNctb@r55ii0eLKS+nS>x%jw-zi6om)~Lt7(^VNU7U#g;9glQS;yK-DZQ<tU~}?agR?%Rk<*o4G*HNa@B) z%y)hlP%GM)q*Tb(NI90I*@H1g3XFb#k_Vs$bxe!8c@Kf26q+?#tUiBzO}(mP7k5T zHTs>;d=`U_{f}p}u8tzT1%rG^)sI7mG1X zYFjDBz;jdfs_5Wh;+Iz3bn!U@wTs@Caqr8B%_*B?O6lFb?v{+D`e*h9lH_mUq(bAd znk-@Mzy}nXlnI5%kR;4uVZ$F1)g)2O{e}5I=B9hNg@t5)5h{4}-3F?a$K@}C4fN8s zR`Fk{UQiW8wws`S`;qV=_RONoPYSiB{{#8lo@bsdz(QC*0lvb%rUU zZqXCzCheYc8z-hInSzv(TH@L@SWzV_fc3S$AL8PIrE72Lqu`XuAQ{{<`sa1w1QTVr zms1DW3B2sxykt?ZYq;A87SvB<9+WaZ>tha#SmO09VBXe>s=c{EYGQL>h-){nVI&0b zztDbKMEK3ic8B^MHg?M&*GNoG3|>lCh@TuCRSuEizNpjjoEM(qIombRfdBi? z(ZjtPC2-8!eC&5>JvqC2Q=Wd0jNW+f^NCf^WNBkP!x!$F=WI^=4i zHU}APu8Fj5-j3MZH<%N8sqcPD%|YkxJX^rwe%d)dC_Gc-g*U1~YAbF=v1-Z= zsvwu(kP}oE!3thEF|%Wzc~3mM&Eq^WA9R6Y zZY11uG_&OWo7r~OeQ#lw46CARU&ZFQ#?!Fr`Rh0KGlzF?1ZqNmc79&>Hi2x6mvWvy zyQ%4)eFtJk>oxik8F{BDF8&=rTs&1LLa76c9fwiQBSO!XN=*qBMoJ;C?!ikyurgP?IZiG}bmeC-ig>>hc#i!+B`JC41Yy*u+n= zJ*HYlOcc!yZ4w=?`Q%XG;J&Ke3I5iWeFPhBw19N5B(tCI)AXy@?aE(RP)(C=QJu?I zOJUfPU8EJ8s+t961tUGuh~NQH4rP*Dke{W~LW&ooOQoKx-gOTB%|Gghc&rZpj0+0; z9IlM&*gAOE`X0R>|G4zT%qwOtleoqGj7NXIe$VK_>^Qzn8Cw{l06X8AoUsWkI*w<_`g(-{MkI@Qt(>`d*1$73etD5={9O^`ZhO#ThK3lH?@{+OA~Mv;rJvdir9}Lx7%y~;5g5iepUrfd(MbIdns7iMkpC?M>O7C!27xv~pV0=< zDKFNan@G0q9-$2eaMJx$AY8_<@x@w4$uVX?@L1507Y;2yvC@@an}okHqvdVeLU@RM zDEAM>aS&y5C_1I@Swj}zQGhENP0Lo{+KWqxMMSoV#N}OG>=4VH)YznuHdHqHFchXS zal7Mt_|U6IR?cwPhIx@YdAoQmd^<#plg@KFwYXJuWurJCeFGB{DS`MMxf#+8B-#TP ztk5^U_epgpjyfjtS>0VLb*bm;;57*N-aY01U80c@N?-ut{8hpzqbBr0kuAjq5eVdQ zEpyc*Lm<=4lU3NfUET^^6l+Dy z+*!dT7=E5rn&J3@Bo39k;?Sf9Pa`)b90i1RCxpD4w;7dRR=pRPZr z9rDw^C!T|M<1{Ol#7IxUC8zc8j%o{~o2vWo5G$rPYJc3G!S(Xx5+_Pzbu9%eQvXf` zm9W_AI{RjRhV#arDE*nsI4MED5^cJH zzV(t?hAFGR8uo32&TnCM142mQqbF=3gzj%#K(8M5tzXfpd*OuUrqn58^uq>@3tb8G zUyQH7zFV%VdeRRETcW*G>k#N=qECrCJV53Ag05%8U^lMD{Bv`5=~(|!^y7j5C|bGw zFiC2h^pg!vHsYIaX`=H}Z+|k)-D?c)l5dh+G>Jd^r!DtVfY{#9{%PLLB@{vT(LcAu znGxP3Wws=C!c>{b-xKAr`y4fheDquNwAk!#E=7YMx#t2`oSH`gfJ>89hm9L?zxyFgX&XkxNl_#dN5y#2GJY zdB9SA-t}7%17C(ot1SdSuy-EG3K!Bo97CwT5T|w05X%WMtiDQI?omH_I`#VyLYT2; zD^fQv<-3xrT$m6$^ZQU^^M#4orYB0O&(-%^dZNJFnzR%u^5XC1&r@$9VLFu~6DobZ zlJtpIzA6EV{MNWJ5rcahb$3-#S1%7Qk9vhBso zPEU$Al&CriEpJuTAi<}{iVh5=R%$1^wUlemU4D1O<}t)S)cX%=qQ8sB1Hj+ItvX8w zGCd@YfvRPm<6mSotE0tlBPdqCjTGIqg|w+0N6 zPiQWmWl;0D2>!x`lLsGh_w_ewL@PF%dmB4)TKfTWR zmk!dX!TLjii@u^-p^KInv#3IXx=Nu$640{wW3cFZJgP7muRb-EYm(_u;*^TozGlj7 zwNy=KIc~D~pfGqSc`yMVyQ5cJmqnB;ablkjU%Z-#)i?2_*z-AmmEWSGgX58^Wx|ZB zeGdM8V>|PHTrlfIVLh^shQc$8I=o5a(Rw5Yht9j#Ay5eSTic?mMw3VDKl|P%06iSO zI=<21UI9onm>y0V0`K7n(PgEFC%P*b-72erQ(>>bHn8w9ov!G>t!M@;X?!*CF{zGg zyqF4Iew4ZTk4}})1R}Uerah(W;=8f|`0QRmPA3QSVrR53H$f3Tl*XZj<5e~5;vmC8 z_2Hu)dIjd0SAOt2kJby@*`rj*|*Y0N;Xq>uEnBe0dlOQOj>w z8ULdHwB^m4B0^PI&oV8Qnck!7lR(QN@bVAc8-x=2xk+)pgblNjmY{{_m}|ckx(e~+H=V&O*-1}pQ5Z48^2Ibtrtj!fNy91kZpwK!K-&u7^I$;&`M^#g zTy@`?$3m+oABH8~PjfzbPavO=!{K~`;8%T@z^ad$p|DlO;+#I`L{aF5X-ZI+7N3FS zvZ(5MLVf0Wdj1KjYV7x2yq$}8Q%ROuNjVZ?b+)t6(@K3VH#6=nW!3k(Um^!lv^rW` zt_2Mddq%GNY;qzl5$M=qntGRAK9+y(?DB8h8c8~8a{*Dt@=W*jiOYdL|G$(F>{V;e zyI%8{F2)Gi35aH_j3$*SSkkVzh1A|}SpOK#%Wbe&TV>Br|0*Jx_{$|X#bipkWqn9L z+)*CM&}9lwZ}C|CU=x9_8j`^H77XPm8R+2>mm@X`+rtI2TFZbTl#^U!__U4|(%EkL z>^LO4M(e}X-MQiG<~zZ7Iy0q|l?97KNaSQVL&IV zMW)mf(SKb^bpWJE1wT8sxU%9O$TIoV`>nhL6Cs8t{Bxf{`Rt~DTQq%%x$;5!&yB5b zE)ME^5195A>zkBj6(?)$!p|{63&W^v?`d(0g^^T_55xwWwTS+SwbmY_&Qo{~5RF7> z_$cR4po^0cgo}!WWEh!9MjT6*Qt@R*HI6lo5nCGZ2Q-nzTf=0f;xzc-*N#_!4^rCuT11 z3!Z5?+++oDq@kn4en;_;vI<5Oh-owNfe;|L!e14n2TJnq_zHS~E=O0j1rm#4C>sMMM$vuMz=2|y6PiA46Y#eL^`kN_?+%6qKxn_oO1Usd{4ve?4E~iak|R-B zm?L67^)?Z-kC=2%@VT&UeMIjSD7#;ooNtd8uR?sK{8R}YNKC=(I8H%t3qk832UHGc zkPd>usz6r)<8cWTsN5@G-OxW~5(3#VfZ{iW+)b{-BGrN=F zBb?~vKOdUfOhs;Aa~pJ5Ql*q`qBsUR=o9=2K~(i&vHhLr2&eaL*K#j_G%><#z;$`d zh?!!i_Yn(MHq&}S*PjHH4Et9ITi= zRyhuY50GpJXOrRnEJJDOF{ZbAGi6*%{^Ov+fX>ERA}4Bpf}wt%jVO43kcHO< z;qM3%9;GDaf45KGa2kRrQ4OpE@%&E2wH7fIZ*%kCZ=?GICC7{bVafUk5;CENA(GV} z6P2CpCX+!A=+x##V~P>&6{uPsQyEftRy7b(?yD6@iP+7mG_v}`zya|)Jm3-bkX4C6 zoGv?@{uk^ON(*Uhbzq|MoGku$s3!rs|2Ak1O>wduyUjhv@C!f%x0~4__Th!zQ%&ms z?Oe9>H%oh*2qqwW`Hd&p?5;v2`cz{Kr3YK%r{1(Dk+5Jh0E-&eRZ@R)gn+guN!m={ zb|x@!c)k++pB=%47A@ZD9l<3=`{J=$`&=4gbypw(opDw8t>M7e3IcP=KkSX!7uF?J zNE@X16nt_+5sjMj8^^o4F{qhN%4$M4elCjTUg=VSQIg`%j-uEJ@Gsq8x;`aW(5GQo z7V9j*z%N}H-Arrd8uSW*jIw_Pl&)Wck6n>ii$tv^89~GgQN_+q^cM?NRV;PS>+osP z8Lmou`igMNoM50@igpV11op<~bsfd}bM*wB)cjh@*xS^w4hQMI7)rg570%`H4;ua8E0vx5(R$CGI0e42X)VM z8(u8B*AQDZ?%1pPdg?p(-2lRC@>f|Eb!>ENQ_2f&kb%)g;e={X0OvA?-UlqhPrc9kZ6!*iA|pCK$tRw# z0d`#X zx#7Ag@c>Kv>Q;G&OA)k(yU2}Lp*kOvpuNw9h!KkW?+4{1B^D_ZfnCxOz@&yjZogb< z>s0Id${v#b&aVoR#kIRzIB8=sVd|1497Wzt;9Pn9W4Qc$9NravBlt`Gr?!P5LC|^4~;CsFxVsRw= z^!)E{nnNawEB0;Am%uddVwBhI^r~3#+BG|NY;MACqMD+ar&fIO;tO_FG}F zGirmg9ww)>>3D98z!Ik9X{nS4Yy~SjMcq0b92wtl9t7x=^6t=&6^V z{Ctau$A3)UDft8T!%e#G6%w`0DnnwckQvj9Nmgb!GP`hw9|RD$VI2LorAJ4dCJV$X zsI3cktv6F8);AC_dm{r{d%+@)Q6lk!+pAO})Gpm#w@G!cL@wq$jP1W~{lX6w*PU*x zPcn4fwok;A5FFx?L&pkDj~(L!r7=;br8L-E{FZj6(5km6*Y8k9u+jnF&sWPA6~ty$ zLMHxDuUiAw!q1VKk;Gmv1bSRaPqU^-$dkUi3mn$dc%?f&U4HC=NzW`qjD|Yxk|~Bg z`ZMjB?Q8_An0__o8}==9_WLZqLiM;q{AvBx6f%1;x$EvGWw@d`*eyFF-nxe`Cog`0 z?|CPM-mJ<~hJi8NJ`dnTg8hZBv7L^lRyQAe?lJJ@%M1H6EqIuYM z3v?BV1=G8k7&Um93<*H<&xjXC8yNJ@E~8OEmNMpK-tY z*;f*>V&wat&)t4?Wl+J@%i|KTn&FCwm#-0tXu{@MyraNnmJ8GDZfgIV_@)Ne@>d3X z?b$#^&e?Z^0-t+q9!Wrz=Mc}(;aSq9JP)O+vOIh906Zrr$37tZGkjk_MZb0EJ5Y5y za-;0VB(4`Naaa|b5mjClvE9$z^5#k2+7AM~k!HrMYpA4e<)y#RTQ&=fl)9)5lYop6 z!ncDjh_O9(qlv>qt)nx3teI^}3@3jGj2Sx|O#YzKn!l8CNVHvhCT?M>r65(aC#TE9 z8SM^s#R+dM3~EA6)t~V$F?nd7+JLjz?Dh8Xy{JyhRZ@+Sy{%h)?N_EBeepkDuMcXk59aR4uB-jZ9l8xVVcC=1 zyO;HhW43yguHqZVtUDo02XmBIDsrSI_iXp5qW`S^jgz% zmOFF+M0X7Tr-K!dp$oXU@WZWeeqTnmbC);i)^Jq&{o%!hkEs= zE`Hpi8PfXCUYWSNsa@6=1yz!*EGnYAZFN-;=-a4e?~=XR&zjb206HJ-+bDOME9z4; zS9cJiVdz9{C4i%-EQP&H5?;8yrtlWALMxDYe)D)sqs|Syx8r0^m4{M#!!pXh5VpU`rTdroIKscdY|Hl z(7(Q_lZOqpB|)}FUxBvOaSsnooU2cxe$Y`G#Cn>BtZPl;{fBLaWoCF937{c0b>%T_a<@6Yag&x& z_Wvny9R2?#j+yHb%!_Y~L6n~h5>`UeZH#=LS7-9@)JamcCZsgKE)7$#`QF@0ptSoO3A9t*3_e)fU2G3W3>&Wy8UcEz zMlEOEw_Rtd$M-!`s(&5Qeop`qrIryM86|eJKKr@s7W(WRciW;?HFvvQA3Wu|b-8Lr zdxW#ZYm1sU$i#D3EE=LBv^R}v83t93Pcn}9YJhH@NbfB(cN_Z~A7>l;lQCQg*oxUV zdwq8+34`6Ca!aDExS6agTCAauz;iVTDM(Xx)zo*N-Dw1}Ck(R<8d#pSF75t^p@*7p+&C z2>?R9^&uQ5Ap#k<!AdeBJmnlX7DgkT7sB8;n*K8b;jia+TF5AVnHk$C=CO4;L?6 z&%5ceM9;?cK2J%HtPPUhu|vG5h?sNruiFh2m~+Fu+4_nsbW$AlMV?NKn?9W=_IfQ> z{Udlsy@3QTA(-RWHU2y0A~{wNNkTBJg^%_8+~~kWrFh6neXRK6h<*Fd8X?6mpfFGS z+7aOOqfsjCXwG&>5BSxtO@AkGrCcP$pRXs!{3BM=RpI2tj~xZM_2y`Q{Oni_*S`(V zm2ryXaM)xfHhlV=O?v)rxqBVhrH*g-+BV!C_!s!;3zzzy6n*ow>9dnQ@$ypXdry0O z6lv@*IYI9`UxF)tk=8bNGc9aa1qg=>&9-ysb*Ag{Oah?~b71p&=zF7*=toJNT_0|| z&zn@|WgYLL&6@^T4jfO14Ohr&!Rq11XM=n0Vz+X-pK6;^cuN;um1drLv|24c|Et_a zMi*oSREC1whbmlQgjRY-m4xidzVQp&u1oJW*mn2c6$pJCRlX<|v*!!k0ZxXV&Rplu z<>5TMU^>i-Vp+oMvn{?2sm6F_zTkE<;%s#=^i$Dm%O#3=XjWNJKcPmohxYw)Q0Q@R z;q-R@m6@Q}45BaNpI`gd{U&#@eIP@> zX(J0dmG56GbcGODHC_j{-k)7_9;97U`Z=_GsBtzDtZlX(LjA{9?Z6!|pXXPFJ_3fr zZstniJ7dC)2vo-4oWZgNx=RuQqvkf4|L5s@dirMFq5KeTy}y8>IC~PUDRHNAh9g`{ zYtuk=sJ6dwA|cDEO#AP2)0-%dT30imp=hvRL|u{LHCRb`E@6Yzy3dVj%{skYQfz*ZZkcdBb$f?=vQ~OCEEyEKIkb&p zG(P}22bX?WTe}q&pL3LI@~doizR6AfoBfblxP$~YBWe+ucP{KE^#&hA75Jqb{5oj+ z2$A+hZD8rUi5}vtC41n0zkhP-W)pdF-JiB!ibOmhq8SpA)Q%44c0L^4-be|KZq}^O z%De1`(t@tbZE$O6q41m|@^Wd(9@#3MRV&p5pZf8T-!gFWt-rN>yz&0ZJ=eB&vA6dA z7&u%6?(S()*3|Dgt ze#^VCl7ia1VuZBc)zx}K*1e+uexj#!O4`|bb8t$SA(8u{wb|#^ zB|i&!V?DozAfC8dzG&^^h=m*CtaVE zwm>dhC-MjOfh1n!&->%U!-uu;CBzkHGjvXZdWAw|XaM#20 zhx8QqBhYX)msyDeHiomrZZXpDmHoui?{9!XplxUo*b|;btyDl(1_bqnwOLtt zsavS!iNKid%nO2={cav2V%OVtyC#iONL?gWVFWUP5;pg_(=M^%0VAWkYfbpx_%Yul zcS;&Ex${N`{_@7SSyOy)+l`%1`u-|>qpX2L0N~vrGrj04G+`!nqzT(hasi zcoS_b3Ru$*hiwM#Hk8d;5}!t$*&3b|gs9c^y&MavZtUWjr=AYDJiGd|tG$1-c`>9M zDE#U}fAJF`rF2_7jcV&iqQb*^qUy#xTX)+N!06i!V;rpXbCD5L97{Wb+KgVf+C!Vj zz8ze%JWODPoB=owTHU+O_MIeB9=_)5sYTK*0&X-sdad3d%J97diWxWaUl~PwdxmCE zoUu^-U)u_Xo(#s&mM0FKPV{)v9knHtNJSRbUYV1OkC#}d86TC0YOF7@GLcj^b6lHH zHo4lqX8hlEbE9r%*LfeK7Y7V@eJX;uAHpAE#tdd|O=etGzCB9YP;}dbQaAMvi22pI z01~a}tow_1*Q>A{ zciG4gmkfx>i_9sv`P-?S@H>OU+oqqN>4+p@efMzNR1=dL7LC1CZ(-xgC*j?8LK>7u z)J-hEG6JTS1+)2#$*_%91y^9WO&i}Q0Sax8I*;lanhimXwPWfN>XTGcC~;XB6unc> z>5<`U!$g|$pT!F12}Al7lKx_UWtw{}*HL z9o9tC_6^gk0Ti$V6l*9d0up+aA}E2-dsie02q@A7mKs68h9HJsq&EQ(P&%T5s1SM+ zM4CvG-rw19UH9|c@B97n9dkf7o6YXboc(v6GeQ0&F|q%a&b1y!#~dDT3gaRu7#fu zAlV_)*iSiu zhsDF=srXWLF?|`z=hVHz5zO+hBekmM3Y7^?^ku|~OwIwS0%bz~k-`HB8{Mkx7GQ#v z2{cA^>qpEue|}XWI1&P`_ml3+S(O129Q>h{CjW{ICIY9@tszhhP29hmxXF=~~Nte(A0qKU#DET{QFa@DEvC7iBD z9*A^qo6w;-llmQ5Ms&vTcldW8%TU+z@gY|TRo|(Dz|#(%J?V(RA4rIgKUUautJhjqRc`y!9Y4{L)_x94VSw6$p?dljS1 z2E~p}m^Ru-*>n`KUOQqC_JudE9-k%^(ENi1GQqH#B3?BFryx}_j~%!bjJAs{V<^mN z0i``_5ub1DFUM>{Z@}w-;(yJ!dm6a#`C&IxWS*`83BkmgbTO)#!QANl<|vUcLgFx? z)(aq9;TCH`H=!Nd>~CNBNebf@0lXJd@uVHFD`+H<()RBpM;5=INT>`oN6yyH<|-yS zM;Qr>y=y0V9bqzSEYDPv5$Q+nx3USha%wYjv-*c$zt_$4)&avzC?*ADUH77M@L0)9CT9RD{!? zn7^VIt8>}d2<{SIvW098$tEIYvNy6eQv?Xh%5CKhAFHc1MfK~R1YoAN$! zdKdHS@m}2v`O`rONyWrsAaaMgZO|eAY4HwdQmeS~IFO?X>L?&bxkhAQ97-lh;A&#A z!_pSSk$)=x^PO7(;5$Vdf+hL3BD^F29HpPBq{akzm8pEsCCdOfpJyEHhsS_*L%9jpI(;6(|_=Nvt3U7~cc zz{0=+y%=%1G-ZUO6nfgNE%V3`iogUoQSV(LT(S7n1T-2wgXd%~3oPdpS;w%X)xAL- z$QK2?hHE-?FV5-6%ETpOBLQ;vcc1|SPboSh%s36+g>`29|zA3hvn;%@W0WY*SNjR`6rgq$LCy}tqw(O;+Si&YM+rY;_GiwkcLw<@T>^`9d?DXazeOoDrgAlkV z76j0xRV;+;SeVyhmMpvGk3@fV^^`(t>yQd4DHhvfk$lf(0qONb?a*McaF zZK`5Q4z;9$6%gjYO^gMbx`_&?#Fpr`YPdcXEqU@U!o@uV<;FMkN8n_uJ0tOk=QaK zXbkz9douL<#zPb672zj}K zrT)`zVA5@mKvTgquQ3^a2pE4WjHch_Cqil_$z{jn&}D9seumvH`a|>rz5na&Rf36IIde?y+vH zWy$Z&6e0FKi}`cagujNtDTk);O&4sVPy%xe2M99mm(#(3f$IlUxSJCp=nCL$aL61} zn*uz9i}gQw3GT{n`OGF%(SQp=G(74^OhGhr4btT_p0*uGN+TIHAcbUO(Kb<)L+Z-9 z-CQ<^R%8oF|EA@hxyvB(=5Z4!`tLV}Zn^>H&6G6x_20oAjNEJA835OCbSEg5K;D0= ze)kyT6D?}NQVY*i;gUIr*zf;Z0iV0G;!DA#q%n90hXMDRoXs6Ov19vd0PjZZfejqm zBD!I@K_$X`=ze;dA6B-9@~Tpbk(OAXIHQCi0ZVNBT+r#=?{sgx4>%lt4oJ!X#F578 zv-Fdo$|0C9z1^;)y;s~lmCpLGcp}x4+7`pZexw*xQ%I~Ww#AZCmSID(vHR#L{JAU zw`S}CpfjLs8en7SoDWhF8uBmNg3+!KYyR6G^)}X0LPfRN8j4|>r@&4((1;^5OjO1z;J_4%7Iyhs z+VE*Z58QNU?g9$r6Rk1)&@=yK);vHHqQ}zVX8c!yUYU*ExzA-@7U9Q?^uGuRawCm6 z-z7&IkVGjf??!dQ>xhGSEb$RV)*FcWQ0 zDYsU5Ep=rMd)*D#T6d+VfKK7dd^ga@lxG65ab4K1semB--zCRvh?on(`8ntJEp)j z!3%8_k&oKeWbKaYvCPu`_~GYvKcD3Z&*5T;rK);To%C6Iz>U4!kJ+-9LxoIA7yYQZ zL(ZS_rzV`frxa*og9#`NC}zmp7`B)hjG&8$+F&KX!kYz6HL!rYG;X05_$G{Gn7{$?gz$u46OD*EN#&%bq4mtTgKq$`}>2%rxIPSTiSOBy@JdG8PbU;I2agXYeJC9;4KT6(SyJ2?0oLmz= zB$IN-nf^FdCdJI}I2Q0ySqQ%p+7=69t(u1RpRoYNuq|((*7q-O(7=Rs^5%>h(wdz{ zJB0>rZJkB8pHNLRbU-PEo08 zB>$EV0BUKL)i|G+kCJ&0o0d~~%yCQ6T~E4z-Uq{gNAn3kaxI&fpBZ!GsWGC6G!;lu zPMEsCN5F@G7!=ur)fJcn@Pdh(5h2Y5L&gX_d#cVx=PMZ~yOoH}lV}Z$%OD9ARGZ|R z)UEZtcKw@7<9)*{A9#-=m+cKtXWn)HO_W6_t-Sj*)W5C}xAG#HwBkH4R#zdfZ!^=Ag z?V*vKWpZw8N>{f^57jVRL-b?+`|`((VbLi(_HdI zZMVq%Uip`YTRT1~BqJ5jmE}PbS>=JqnEBvk1xx6R`<(Qz;j`#&!!`Yexh$Rr4}+L3 z<3z^Vnm?byVG^2P{zo)0bfWdrYQ11h(C^BJlDdgV=sdUp5d)j8CaDtXu3t9j1i+%& z;J?_!HXs{FbAN_;mLV5+b5CE~;ut1Q2k<}Vi$X%cHD!GE{%7Hyfl6o|8kP(?EFuq? zi_9fOaqog}r|Vy3hg%*V7_4Wxj6&vAva{pxa1 zX7tJioGm%TY@%*kvknajnL*4XW@d5HmaedffMCs{ z>?@8-_}-~XnKc-^>{R`J=zHg{UKVk*IQsZJxqVkvpY!d=xIX8TPPwS7__X7t>Wb88 zbw&Cw>w(A=lxiU@;9F910J2R-6iJnC$f1PEn86*p{JtP z_)2|VKaXAd88ST?L_8MwWd&+5{V$NGL$AzpYGTfxLw8=&0%vtQv7KI|SJ|oA)cCKt ziO}xb;RtOC!1RH`mSjKC@QpOe~VY=LN>5m zvlPqqAH%f|7`lu)lo`$$uBg4I_(#6SFLM_5EI9FhTOIGaBZ+b1HDm(*K6Y~3g!9~l zGe@UIZ6*k{e?o53nDWY|_aOrv>&q86`;&Aa3afhk0^#qyE0BDIWPvQNLqL|Cx%Ac5GfP&wE8# zEd*Sffwmw5NUe;o07TW}H(?YgC}U^QlV$)}j&}aR0D+H@WzA9RmpYJs*yw-uwhAAG zwy+Z|c<{7PeyUkozO9-5S5F{|0qD(? z{-k+08ji5z2HlduzS09w^UIe%5Zz^ez1jhCQTuN^#3&F+)Y8VwMYq!rO-_5 z@DimDJfKXW`U3^CM%!KqCBh*l!k0O90!@H9z;TIX%~ILRMfx@f90Yo4$isz;0+go4KcT(aM*U*7a-CHvAzwp795uU1W1*@KMjnXSd#h5=^zMcm~S(M?5p?9 zBe3W5O9pfrjy_DHoCCVf+Mx3TOuBy&f~r!%%35F&J|6+nevtYMARiQfPWRd;WX0wG zO-O2jnRszntt+p|lK6@I@WU09Thir26l7^SYTyonhaqP7RjWuglX?BfoGW_`QTbrE zY87Ec$=Me-4ZQWahQUzTrz`fr?!=mm3rBXj*BNnx{>92|csTReph+oqwNQi&n#bC# z1i1FWDF=eCCC@6M8DM|}c9>|)pc7 zip24hzOxj)yOjcR8~lI$8vu}b;q^lRT{uR)9&&6;cM9gZMqlQjKi3dOW5zjh;bg(7 z0_YU@M@{%yy*94Ia?7P8+)59|!3b6N#V*Dc;F9gzN_s8LbzHR*ZTO#b-w<;-4X*C@ z`WA#{&Oo={X{@+P-MY{If33ef|A*;P^8+bZ>my@F_*B_8eZD3&Au>pe1qQ!<3xFL1 zftULz21J5TMWhyRBLsg*g7Tl8JP=_5y&2r~Jl>d-qx)Ac^X0COGV&~sFNqG+kzj1G z>fQ-06P4}y5{IRukrWV-A^-Esv>-I~lb~Vt;^x8ImRJB1HQK}#qp;dc-Az4RuC%A~ z`v$$SFG}~9d~R$SjcvYm5lPrtzBvxf_pzII)=$=UUDB~K-tnRBY~KZYTJ1WP^>Y3{ z;lr-CL8K08VhfJ96`xd#*dmT_0N4V>XWU7rW|GeQ5OheLvlF-2YIQVEv$OPSsj4yO z`T1tNxH2xNe_H`uWlTPeIJ(c96c&Zh?r7$nm|_sv)sMx(A)$+mobchSp4}41_lE0;k!{WaF-hXpQT%~B)=Xg(N!;LW~~4V>~? zWU)Fs*InD_Cofrp!TmEmE+6@tD`GGF#iIA5KymZ;Ie`ZfCee-XJE(!ecP()%(Lx8i zfvK0r!a=evB~(7x?bK@)x30q8IUyP+4I=$7fntm;yx9SVe)6g+b8;D_GhgH6vIK|; z2CIU>2JQ$JlU%Dvj+&l>PtN6y8ZTA%@&3215aucD+ycAt(Uw_wA2|V*AVK4nFcQFO z?TEtbM5dTA(^IdM#*E1ww*h%W^X9}#fGbZpz-1aGilvVBF9B}J^}uVu z?}NSg8^8~^9{@b%=k3>Cs~U37STg0dQ@;Wa+2R0E4DM+x)qb1<2M9-5XF$+f<vcGs zmmt;cn%}prKnD(PR02KOg1ie713`{o>PW8W5Cwr2QpE{?a5)f)4d0!8{ZS*| zM=MS;5NIx*heoOPRRd7A4MVLaQK;+-FftXu5>t%&sBLp8vP-TEdrCq7WIhB?4Z-|W z)3m&Hx|>{FmThNPE|1;XaR*`pvPJ+>9P4Zb83mbQ)?z@05u{PR!`SufMvX-i_h}{f zx7C7o)uJbxK7YTD@Lvf~gQEiBAvh!~$(X-KRdkh%RgCSA*nkga zRU=G5$6TT0bCl?nCbkv?DV(Q!;ILdx2tx^ zVI7v|73Bfz?OTZu@qO;nQyka|Z*6D$orGqa&W~TW6jRpJDiwE(iazH39w}CkVt_ZA z|HB!<`HSr{PINli@2%>kvc=R_qS$7oH@-()K{y`n*M$%0U+>TZQW+U~jCE4SGX>e) z0N~r^21>{+a(J#z7>FtyR*=;!Skw(v4D9KiLkF?brN?1ES{D{V3?tqkjYRdgsuC{G=@=e=knUA4P%y^|2H64y7kyr+EL;& z1&~vKnR3qouq*J~en04g3Un7Js_mt>HRE%(Yy(+HnURY^Y#YpT6&~Qr;F!55jT#Gx z=9s$tWOKw@631sCJWARkTgcmJ;5YtjJIFu>*?%l#$V<)Z>ou1#0_la1Ky$%Y2X{^B z*WrV_0BHSibubU;XafsV5x}#={E6+SI~16#Mvow}0Sp}^>~3w4{NI*t*g}?4(uHYs zgP}6#TzZz=X|20rz~I0|7W5DEn{zNg|1AI&Uus*6>|j5RjnA^lRKf+?8LNQD)4hLo zmxJE^;cF!AJH(%Enm3h6z9q=v24Az+q^Kpj?glrYV#dF~DhA5EiC4 z(b2KWq@<9vI3i0$-Xf*q%n=6gTmVk(efYu@VTcKOdn?;PE#DK)vE>YhK1Ov3D4`Fw zS_39#cDtp7rY@t4488k@j>6QGV0~JQ{tQsKHIk-t-8bG%ArxZMqf2dMBA&si2~lX+ z{8LeROLgurKd8@68E>JvkdbNCSehs|@ZwhMP%qmkiw0&{=-M8qUi6z8S`b0@KbxI_ zHsk(WT0L3b(2lHVyfibLk58gE?{@8{+tE3w+g9qeqceKim=@SaYN3;+O0|G2o(zUS z{cz`fe$AN;$n;f(9>`3%`66V8K4^+4LIUJSoz_6=1`EKHZq#o9mK_T}43Jjl64r(p zMVM=^tv2ML)M&X3_W>lqR%;ksxbV8gC@wdX7VncwqWb=KaJdBDMAGj9V)#*BaNnMn zo5E0y)>g$^NkND9TtmiOX6-t6C1tc}%0=C%U4APxWD)xA$n7e4(1gM6CQ1}eY|s2JH}Jx8t)4KdGOp?8^qb3os9R>c;JiR8WsFz*|)&~{4h zXE(e)z#aD+-RH7OmMkT-WZciF+;h(L5$Ygg?$OAkvBwE0mK7kas0$Fb(>=Jxegod&?n70D@)-1c1qV+yuY z@JzRjQysmrbQ}Oh0Kb2@PhFVE{mD;Ayi%iIqpMt8^}UzVPtJAx%^B7Ie_g?S*Z^`F zbu2SP?%r6}ule}`2L7(+)4;e9jGZX8IV(ryt|@b&zXjEY@Un;yuIqCu+%aV-<#G_@ zE#3yE1(qxW&bn(|3t7Cf^$Yy54S4Hp2m3Z1*qTuVAM82_fS|Q%=BK1EX&B5piLQ1t z4{6lEY#uSoa2VTy>K3xf4}ifc;~PTq<^XQ=`VN9b;&ypNSv$q^9u%PDDg$ix>tpa; zVCrCOEcQeWv+{+fBv)=aJ~Vma;AzM-F-_4yOQmj|=x zAG$UjCCrQqZA$a6tloY@3G{|i8^X)Y00QCY_#li>O1EYbGl&>W-R~EGzkxD4iKfn= zbHd;GLni^SGmWST{>xQQNo<$RpCMDgl^Lj=Q;gt&08dx^vP(d`>;P#alhqp?lb|0N z{mftv$$ft#ueVLyPfnW-G(Vg3x{M3Wg&y}cUfKF^Lu~N)BO*B(av)H4dVjbKZ!zr2 z4(9!rj%NTe1up6VP|=hh4FHX%{p|P;fT0aJ*wCT(n-oUweR42rA-f(I=_hmRGii!h zboZDFmMo!+DU;`TEAuWoi8y`n@~G5eOZH1mO!19i&8SM92?b|=zGt0E=!-&FO)xPK zP;Hq}&tO!QIgo3FE*oWFrvboYM}MC$m`~bLb}Oygalm8)xVV^;?X*BxEhpf5ShoPg zx%p{ZCW<~=bUi%N;XMGK{!J3sCc?WLjOQ-{$(+d0z%(WB0flkptSp7KPome{%f5Fy zf-PuO^`YR-vI@>;I$(Ac&`KC#4u(z;5rD(Ci95WURqtH!F!+2HGzP`c2h2|Rp8)`S zqcqZUX+=$h9)N}W0Beu{-v?z7(?zb@o~gS0NdbV2850bbis7_+m&49X>ussGJ+;$W zZf;VA4yCX27V~ngKJ@88)~lCfw`?PzpBw*w5?GW76nVXZ5`lgXyIrlb%?3I|^2Hv^ zrp5!ZG3>u&CZ-TerPTfrqy3j#dhs3IexCLh zoqk_GIQctWio+N`wK75(@fdjmZTV^ap2DPVYlFz=R;t!SA!v$t-Rf%?+_j54p# zS@iTJ4$y7je*wA2Fn0LcCzmNWzh8FNoZ-|2_%X`jUd+o)uJc_f0JBWZhNBRC0O@c{ z7DY*50gu8svl=FDkUslVHja^9a(UV)WDl+%Q%tZ}ckIY&WUroHs4&@%UcEa1a5~HG z{oA<0a=)f^Kni|O$r-S)_;+#Pp?Q)z^zd1xjIGB3^S zlZvwa$WDvT&wHukR+m;kDUPNVzIp@DE(|T$uE3|>Ks<0|z{N=8^f#aILGjeb z$ZbXyl#Qgx1ZcT1&L1p8P^=Vl0jni|eKW=U;(3`5G|Hb(S@c4FQ7uKN2BQ(<==9|- znh&N@4j)3Asx7rO+P!F3ao?Ow$cmtf1AxP0_$(j^Q234 zKH#B;)73mLv=aSUkfnVJT()4V<23sYcAIJh1WPg`-rNxXkTV-)2X3SUTN#QYvGnl= zqXF6ghKYew3|zqGsG~1}4t8;L`MOAa{BLKr)#3b#!alC%&<^`0-bbte@6Q~~36EQW z-8(oD3UuJFSBq=Zzz&xA@eK0hfchU1Y9Xx(QlXk5fN;C0Lc1ITSmM@T$P#vhK&}^r zdBhJA)}yZH=!`gX_CA;029u<#1l<28pk+YuLHNi3yly_J8&G7$hXw#7#Hs_i%)=lL zwUGPyDnL5mY<~xJjM!`zz(jz9!RN5|hB)X4GC1dIAh*extxox26mUuUz^U;EqJrH zU|&iOG|lDUtmh}K2+bb~CxK~irUY_-dNcKu@C{~Vq`jtGlnt;mjk%D+KR5*MZXuTuRv5e0o+OqKnyjOPvP@Q63PJw=mHYtB=T{BnUgQfN9AB zF`f`SwKb~a2I)KD&4<8*S6#!W zL=P3WuYWYCxgT%><8$TCX* z*7xdHvqF5BYs*haVWzNi268FDxrd7}PUVKbMm!-cA6rvdRcsG{f|C5poE8`4S>(80xFmpq;>#vE)D=W%zne%z|rV|9N$6? zH6_&eY_k0f_+5a6fFS=E-O7vEqgi%Zo?_Ug3vu>_QeBM6ND|2>n)3TOvyE9q9n7vi zTW%^0Gh6}5|C!7BLpleM)NRnT_9?vpyu>eo1N_^v2BjP60om$nHgi0wJ3A3g5td4CCB(YaafZFrow`(yLSY=ummpPifk;Hk?OQ9Gsc zu~YP-y9y$knoH5`I;3O?ft+v;$E$gseVwX*{GcjjCJDH-t6{b0MZp(|NdGG!sA-#5 zfnDKPSvcUna&~85XJz|Q^4GW>zfZ3ivfH;*^~k?f*Z>JY!qX>N184qN@a29~)3DUC+z?ZPqqlLf;9&}Fo7G0-PLg2Bj z5c1Kjru0nK$E9+3FPO#&3|aNK+l{!wOX(gunIFXNsl&?Y@ICeNjlqd2xyY2}D$>?- zjNTcCN+8!qx63~2#EnrKE!C+8J{B^HF1j+#pAc*cN0zPTQ~>@cIG+^Il_AZ#Uw}LZ z-RDH^aEZ?HgPI#q)_Vi+22=2(^(`1THmhNUz2nfu+_#bXnB}^HwO)$*xcT9RUewIn zntE5bX#5l?8hbmC|c76GaP;)9=(a%(QX zjqpLV#=QIV7+$B(`4a#z)sMsRr;Tb=L7a8!4u}TQ=1rGsRdlLWDCT$fPT68~00`Pf1@oaD!P@dDa0~=f3|I;? zmv&_UPq=ogJd#6LcB`=$x6N zM{`8CKQCmNG;!s$?>rwr#tj(%?2ZN^8Tl?C8|Aaash7TmTly=b0Q3@E`m&+c1dlAu zqzeQwK0!QD4<%-k2WBMw3mwy=S_=~d9PjD+ss?H_`v<*!>sV$if4t&6KK=xS~1ZzOf;D>G^V?g*x zq!=)w zUeEN7WQBdWgaz^!qR|$J^k|4Q5X1{TL_XXPVeAGUxE(vH9Q9h~M||6UrOf}GqV6~! zgiJsUmU3yQFA27C3TX$ELq1&}o2R9%8jwsGxV#xWg^T1DTNR8?Q~v@hY`AG`Y2r^H z1rlCugg;waKbJcU@mK4tQX7z)hqD~tDi1zz&qf6#iX>2V(Mhp}0j3PYi!0ts-R#;9 z`H#(};7>68^7CxJ6J9TX#IybrhBAMS*48+UZ%vJN6+m5-{cosg=>o94|N0~U!PcA#uki+G;L`>Ir~Rt9 zBNSj0aBUu}X~28D7fZ9p|KOwEBZ@o@$K6)5TE3A_J zai_AwJ@}d}%>ZGEX$;xZsvYd$t01=m-T>nXAs>>2U)*9)q(8bH0;)`S6q&s`IXaJS zsbYi4P4AxE{Z4mrgSCZrO_4S)wiKRH@sJ=-qv{`bbU&m(1c`R(x zj`hlfZ)EJQURM`M`c|i(HExz%RTuO|;S@UYDhuFV&hanmVDKHk!sPI|Rdf*8f){Zm{?oGzlo_=$m{rchg-h9*?VIkw zCOCtO-XF}F{s08Kg^k*wK?!kr6qv3PAdZcd4Nh|y8yCDh%DWW+hMEfORmPg2#vDy& z1{GN97)WxI8~n~61d*x&q=XN**DCt#ml=Oh9{_$*0lW1u2M7l*rZCIlT}i%TGzqAW z%)#UlaVdm$<25OKWosJhbk->_g~*PSrO)njPA1Bij$r}GO+lCcv;-m(bu3&=JL5LE zj9*Z7s_ug}=2C5l_$MhSyV(fJttfKr8N+!Sc8aI{K^SdD&zH+PV`;v#LC*Dl{7g}u5YjgUrYsc5Tc zlaEVBF|V{Y%MXntV6XNWLJTjCzf>vt`JR8qr{`Yv@$1Efn@KbY^at=#%$$Ip8<$UH z5MeOt8Wvznn?l?<7mk^e!+??}xatMWNHYKR7Ifl;R?qn~cPqF|Im1-R>wC#*#3d&|C`l*go z)KeWfd_$l=;6PMsIv3C}3zK!YxpABJ4OMJ<#II4A1_Bq+RiCoJCxIe{`p%9ZUCcbUvEk!svsVKS!Rc{IKQeB&-y%X!2P}T z7@1sE%q|YVfU-^D5iI9mD#~oGkIMO-bxif{#z733%uio5|6mkB zXn`BKy2KGB>TTvkMssJw6*23<-F5u5$p?H{;+A>VGv)=G5~*Rq2e3@ao(n_6R~ch# zL&gUyE7FuTV|!yCp;b>Lc=d{9_Vv0E_btK zkRs{Y*I?J>j-C&wIw-P_gHU!Y?BqIe;JU;yWCr4FNOzXD0uoSHhgy@H%d(zy3ExNF zA-S$dYF{>2RA`XGRQQFF7Y?$0c5*{H>--Y`B`!L!=L#;M)#l8Z6(rFd%9>6qek6;~ zYD^?1zz{9C`NfA_pmy~WAOFf*>yAKQg?Ps)nU2i7R0OC#TIhn@|9e_f6@a`+07DI5uKwa?KxW zkJZM*dreC}e((Pfo&QQzHCP{0v}ULI_W#@E#Wcg^l>R4=jACLO_z6kx`9=WqFL9A5TOGwp-zPCo$r;Cd7|5#U`D~EF z4dJ<#tKtVmfl|{Z2M}en$|Gd1w8oTnz&V4+Wl%Yq^M@rXT!Z_`r36${JePD^^9=cJ zh@10X=iM%0phQN*ab`C9Ts6PMp-lO6EXH3Ie~Gt$Grfb113Y6h%?fx%1Q^#3Y+BJX z(?PPBCO;)@&H~>6+$Y=>%Q8}uL`_*IAUvlno}`_z4MZ2{{g+IQ;$O<(|DB+*H*ntO z-#ED&gzKlPZ{0?+LvrboQ8)`J)F^SrSUK~>r^5Uj?ND!s*IJeI?Dg@DAE`XmdMPTOqo+l= z1P}sIiDzj(i8DxLrik+>GCsjYKHwDarg`<6al0dV>4w?wuVAf&C}Jmgv?HLS^YkUw zIr?k%tyZDeX|K^{9S}wcVElqFW04i&Msr43WVSeQ-rSa5_{^Fhi_1{`$w*bZ^m)x` zp)FB0=+*kSKd<};@Wi)vd#p2^KH>WB-Q3R}5^i3JKIs_Jo_^-`Uzt(sFl!d?Z?{j< zXG(g$lM!mG&0z9o35|Pn-bh3s>bb%LE9it^;zpUCDrxa2?z>}+jPeibLKQBxv-1OM zUp?m-^CuqKgzPeUT;>g%@p)s>ezR)T*!1OLcWxKR>cg!cXD%I{xRayIbdQ`|zA5@s zalwAU9&gLPU~lAnZxI|{ShLrPpbfMSu#XfgsS~Xb<@R84v+rjA_-kNrcvYr84&7@m zNF&g!E-;atBmc6qSM^ba{l-wY2uI<=yYs7W4>A8r5~6zX^UqO-q(9G0=Q~yq5&p|`JLd-E}(wQ2)E)jA4^xx7Cf0y&H-2;sLB|ow*WV5_MQa|-8 z@?5Qs@-P=B-8WY%ix2EafNe0iaL?m4Tbu_(dfLk9q?6)L*~qsP$duiD9v{MSF4Xj0yNYw~n+5CtCKLHxEFi%nHztIvS9JwD~XK0?#?~XI-J% z$e+&jsg%|UzITj>C^nJRU}#Jp9-{nD))WRMd5qk#=b6+0S;D z=JW@qkgm(M3vBXi)uE60Ipo=P)IEgQ{0zO+q?S=q%j?M}m%lT+O|=P7Q>T7RecSvB zez_&Wz_vrOJIm`sM~Ss=88^yBXtmOj2rDYB^JO`HwCYVe@JpWgN45_P z`YYSX8}ARx?~M)we2X8su2dn&z1pUAJ-h7yJ=5~~lEa)CnR`B6n&s_9^oVVxZKpguwa`ztl`qIdfcm;KG(S>J3mB%VBbK1~{)S{Ep zAusi$meqR|sC?EX+*2O71S`5wtKw7=nx2?!Z)`rTUYs2L7GHCH+J$zMp#c#RkKarb z&u>a*On%@BF3nidl)td>{^{buok_t5uXqo8p78QNHLx;)_Aq3A3>YX^tAVx(<2>q3 z?(jnu2`qb$c+;jRZ+rI-e20b^ylRAo`Q3T8z2EC>gJGOE5dQ=E-n&#hNtpC#D6das zOk&hxNRn({32~y8aS1w4EyE7lV_9|?>$JDLPCQkH{htwm&cU)S>!?@Y7gOY_C#U7v zrCgW>>WBikW2+0B)f+23)`aXO@s-RsQS?)C1J8#g>Xw$1veqEqw&Oaz5->r$t}T~~ z9@1(~WlWL0JgR(`hcxhgkO8VexgDaCr}E=grt$d}KmCm?5;nZFzVwB7Q{uw9?-h&U zPevo(R4M|&Oep3P73z}#Gn_nk$ZPj)0YyK|BISX87)FyeI`uwIS$w~lJk)+>Xp8^0 z@3gw-9`wx1LAHW*V6wV9$E#)W+^{v|RP1t8z9oBAX3_kaFjIXg&!;ml zPo$V1T>SZU47A7nAx~BVNzP_^R8a z?Lb}m>$cg9QpB8`6Hl+im#1Qk8yQ?4V{>x6vUT9Tu9J%s$Ig5(F{xNuAskC%{W>P7 z{DwN=tq>oghbXES`IIK1$j*hmLc-N~q<`cqPe_{zf;!=2eC?v|C4bC9kYaU8GH*oQ zdh-#+W=SQ2jRT@1Mh1Dn9c`+CrXTgH|9<)%m*a^vgkiDQ zQuj-%6bRfS#XHw#aRPB&OP7vNCHXDjvdL2MMBs$mMBXDE8gN6n#gBa%yC3vLpQd#x zd!N^K8ZsPQeJzTxW)xA$j%TVGrqpRS=1 zW2ZFhyE06}+nnM&{e1!69c>IQP|ax~`&YTdiD3VqRF)qkYnY&+7iaytPPkhX~AivudbB(D z##5IcUv}9Pe)SS@#)fw9-g~H-XN=-@%vpCdlm*KY)phsqiQkx88LUr0v4|Qu=ZUB# z+0-v&hhe6xcK*>U#iL?(lGCuiA{lJY2E^6yzsjo%e_ed=ny6pSk8;vzLGK@$O~>jc zK`XKTz1bzJndMDQuU^|_0kVEic+azwQb6c50;k)CS_Y`%7~_hh10q3>_M1ysa>!+N z5f>jBHfyUhge{2IXJ;dS_Dfc*PrP_$(~Gw*Jy%LL!p1{x=$k)7l$~Q*BHneHLWErU z)+FHTJ>aYD3Z~W7TTaKPK-L+jC2o}+cf46%FP_I7@3^+zRPeE&}NJc|7Lj3%F- zU$AQv`dj+zknQ?h-T_u57A&xzqK<<>QS{QG{8Ok%ZWzgI_DNMfz4?|0(fd^PM*_+GX8p_FGsySc#H z;*CreVmuM*sPZ9)H`(P}8g_EuHTbbHZ`Px*GROBbKO(tYr)IU&crX9nO8R&9bpPI3 z&n}ur!rGT)ptgt!&FkmJB5ESzZMlAhNo{xQDyXSkZ!qTny>%zC^H7b1OxulD28Y;I zRvo;KOlnM7@ve!TNDfreAl8f4!3W*xo;K> z)L^T_o6CpekFHxkIHt4k=KSs&=H6CR=G=#O9ZX>}4)Q_J^LFRuntRCV$VtcPhu6xT z%b(vE$fe_*VUaqn;G-slMEpapkzdyUo(1VeZ(A9@anYe^e^6o9l9^Kd>VHNoTd?0}1=b zIz0S6lSg_AAnmIc7HscZRVCqN?^;!{YyaTx-d_B?G?cx@!Ay|;Bw`)K*E3WU<&byg z_OCxBenPwHYj4PS@pnr)wds|A^-AVjhJ^BR9vn-1^`2~0V*O73wPy^C=W=J~!i3et zhnqw0#LP_(ua3%f5APx8J##lM_EnDvW~73AsP3QD546zmyI?i3T1zV{cOSc3;f(S) z!4u0iE=393_L6SwEAt~2=ej~RPpq;IHP#ZfYe%=t&My?XAlz!Sb?zP>NqMr+4z_Hj zotId0jQa5S#O7vkyEC8Qw{GoY)5f-cezVqAO}%+u;@SG?wyM?k$?e6{kAF;+-M9YM z^i;p7-oH|E1lqE-_{E)&WVIao-R1J%ckGStWNYgPQ~o<1zP`EsoU#Mg2d{iw;q3e1 z@`^0O?Xe|f@A&)mvm`U60%#SGdAfJXgbXRq(YjgB zIhTaylQlz7-!}<`E36(L$R65kJUvmj=cmlJeXK6e9*>2%{jnPBfoAL4xKYN?5Weh? z`B<*qoF@x9_|f~XLLs5E+tJt7{WV9ES>-F&-&|W)#*L~aS!|n~+t$Z{lgxYhhj#C4 zj>-;%c3bXRoZG$Yy{Kkn1s`1pN8RvIjjq-9R}aw**@0XhsSEdM-_g6+NRBZ)imeD7 zf`TNA{|{B?0GvtCJp2nUx+E9dxY%}bv30R+8+);B+q&4i*tTt(U+#TB{J;8DZSS)? zwYBrq%=FH5_jFl{k8wBlp~wSU7WVs$-;LVBs#BkpCtAnj-a`KYckRNe_PI8^#9G)g z4693Gdy=2RL#_hS*xKIto??lI{L0||dd@iiHe)EvqkUi#SbWt$c zQvA*QX6Ca%^Jf7i&zpz6bK#NE@eQfKW-D)P;Msb(tq|^H<+bK^E#6HYv%hIc_1T(P zD)-tszOdS@Y4`0ku`LTuagAI3-P>7mJ!;sV?S{H>Ffx)h>wPQyrwR#v<1|iwSMBQb zt(o%7z)>iyWLS_f)9?}HIGw%9?t;zEloxqag6G3TQ^>)t%FZ5sXLNsD+Y_+6S7l=e zTyHMFZRo{1Ham-$`8QhDJpOH1C=ycP3m}7qwN`p!??cpXN}R*2pWw3gI1Z<8}Zz6qJt2tIeurAI-0TsB<1NylX}+N z>-^FWZdcW%Gd5n>f7tU_6AfCY7)lP*ZOg^D4zZx>Kv)^ zzD0AtPZVzA364&5}q7 z5;k)FaL)8TggW!K3I3`qId`)u0))Uero*zS_aoeF?cP;gth)@}Wh^ExRK?u`iq=U> zUTH>LttIOGHg(XmznGkJJzOYiIa*%RmvH(tn2a5+aUa$VRYpTQs3wZ| z-#K_~k1P2E94;~`I3V9>L8c<{k#cB2zwg-Ja_TnA~EW>1qoBdeS@C7Q-Gt=g|fT^kJ9a7$6)(@hyK)uXHT$I@Pr&F7RRGG+MnTQ_DmfY|`AVbZit z%Kmp=?*!^U94qH{P~aey5%D;(Z4VA*mXl1wzH3T&@*cIbL zoa|=>x&p3>q>A*JNC*Wg36YkKziIRk!QGo>0awXWshG`lT7m-?<~9Dc!X3$&6Z7$! z^J!@IQL*l8}O16CHJU#d$x*f8-mh6|u39g06p9wx7J&dG*dKcaIVypz-H_*>+GWF-2g51IFcHtPS z)=!vQLd)2kVZu{>X?rjmxqB;n)3JN1dfh!N{k=iDg*;|$2L$e0*jCocoffc9r*V2C z*p;$&3stW~E(D!|qnzm0;Th@Hew9BT2(7`IXgj~BrrOve!b0-z8_{)?(5}sP)J-NY zEual6*j>@}i6~OheekBZzn>l+{YB=`&~`hEGpu=S6IrEWb=Pz|dl=feIoOwbd5&6_ z+@G6R=0mZ#1_~ylE$;dTm?{tG08L#q*Zsb|AD2&(Y+?~zbMrw8V`48U7Wcd$v z<*KROL*JC}D#HEJaHtEWX3~lrk0C1K&c@OkCNv`80GC2LIex(gzPQjqTT`qT2t&iN zY$cIEB=bYe1SUERcyQ#itD!ThfMAFF3J)*GW%gDS?~_;S} zA0qD!g2J9t9w25YIUTN8e8rU&Y;b4Our(W}Mlaka^~bosC4tvpaXxb96h+83tSMg# zTsvEZfjt^D7CJ*w4YBPXqDzcOHfnl{9fy3P_k9Odr7k-e;mR?7#Ru)k?Z|WOV~!pz zqLiJYs}=jNPnWdg>#1vDJKBjGd2C`ry+bK@?crfe+|P;UeN5c$Ze|6dRVKEzxgJg= zAL0+GYIyB!<;!^s+PhLwyv+@tXEU@LzAN-V=q~kRc*NV;>tSwOxTgy4!-TuZ)v(9C zJy)xGbn9X6uM-<%Gr-3#LY8<9^i}#fX!9LQDwPQ^wEn5wIBlolx=g;pDG2U^3 z6s)nbz~H^Kp3V=-zwUF8(=(t0<5oB#J=Sb^FQp+&5qX)aq8%?Da{EmC^7YE;-`ZMK|v& z>ldPuP#<r=i^j)uVwaLAx`_$!t$NO6_avj}=8{5owfPS>=E6en716;(;)O(P zAAzh~?aZV18mCo82=Ve5Qgay%qaGhE+Tx)j79UgJ8LD?r<>Oe~yMePuhV%aOIl8AR z&r%-wc!H*b9C-U7QMmyp1G4$mGU9 zDpPAQzc8I8jr7;V9tMy@*ffP)^>UdehXwodM9*vk^nx}Vj|CjyvccDJ97hYWI!t>9 z?;Sx-Nqs{Z8$m1z5^;t=b2xeOt;!&;q>@X?YY5kjtnI}$Gr->1yP?nJD*$@ExMA2 zm=vM8$!YHPeDy?6eJgfPl)G=R&pY@jA-Zd{Hu#e8Z7&Sms&TFviT_>sMBUh2Bjdhv z?$7&rhw&wEo7=UvrjG5G-V{V%1Rj&ioyoAdFA5JUTShOUl84DMk~oN;Ds}A;X5#%1 z&8y#2>tp+?)+@CqI$tetE;zwC64PCZJ=BJPIcu~g*`MJ_(M*$?*-PQ*5+J53IV<>m zjhei32mB$xCU=HiB_HA5+lJbSiaZ7x&Wn6_xN2{8GNdWbrYItk@}lA4MQ><@6ZWNY zk#&v0?@wM!PHmX6q;>kqd9!b?gYBR8-gcDM5RRpnF{61xoL*7@ZCjA!XpX9SL;bzt zmPpo8X9G9hlcxt4o$INN1t>?jX9>YNSKOxL4e){Dy?36=7Or(lX$eh2KOnkZT*(lk z;AO)OdIk+hkI{JL(8!Euv=8H>>NOM8^F9n7cqTJ-eehYa`FeH!eh~Rme(x?rht+=4 zuJzrdGrrIV*WnUU-B~l?zY`HT?&Av3UQJG+H z^AM{J^RJGHRGVlXa&6x!LRk?@PU@vOVS!JuaWCoubBQy--Q~4>PS=|AGk@X5n$G`Q ztD2h`6%)#Zw*HGR!3}Gjj4J&jf1qaxX>{hcJyRQp^rXD)8_$QnK9@Ad=C=)m59b%m z6Z-1L!naGH|LCaC#m+DEWlC|0Ca2kY<4ooJ1o2D5BpEU!)j`4GQQ|Irl%cVuy_@gG z?q~o{>&mkPr>sTqd7|3U6&$9g6T{AH0>0sYpo_i~od(|zMz{FuLAhTWTZmO6!)Yz`F2 zak2oQ>C7v|Zf#|ub2r?+Hr8>id}69%_mn}Dv@z2Dnz?=5Doop%Y}>bPU9)hRW1WK3?y7ZUR%oELfP~iDBPI06wW_IoL48h2+R0N+ zVtZS8Oi61XOG141+Jf~W=*)t~Hk)!~jN0@){x?~=Z z9sMROs8l65QLf2(b>{b|)NN#X8`;s&qL^fb8tH@flV^r)ZFOOWo998;*=Ws5#vc<# zfCr@C6Pd$*ZQn4Mf%JN0{NC9t20BJU!+JO`HKDTTk<6bKE(b+y_`-dJ5)qb7q99*t zCLHC`sEo-ypUwWLt#?fU2{4yXGC}|z9B-6j!%2hGjdpWMz{+w6crV^656+AH%vax2 zUNA(e(AhqS`TM9-)r8XNtHsq#(0x~I?H)Hk71L$ySR{s|nFy3G5)qGXVugjlg3XW>_Zd;Mj~JV?|JJ?hXbm}vyjdCEN4*bt>iZvpB4Id?q!lQQ4p)p zv|w~7;0Aix1ZfqeaawV$TPB9f6`3Xr@VTv4YW_mm-AX#|DOEJ7`M^*m=mh2=Y@Pi* zC@PO5!Mg5nmE>XaP%FJYs+Y!-D`}}EoS5X?p!3!Xr3EbE(2pp0W(Jsx5Q45aIenk9 zJGrMta^<-}G)>h!5N>*v*&4mo^giSp+Dl`Qp#)g*7#T}YTCzg@h#yKecTmmiK_DW}GWa>EY& z#BW;V@asa4{q(u?%K?Pj#(ul+JWo8~?-GUN^?nCziIN?;uijHniipZ|9a_V*qz0)Y zZH)z1OnadyEm4Lvbr*TjN2dYRJ4N4rIwvzbtJAti*n#K4C*1R*D#WHvE25SVzC934 zcr%1&1zsg!_pMuLb87NF_cgBXHD-3rbGF~d40mt5XlmXX?E*aR3fY;LBQh`LG~yzZ zR{>H&l)Um%PZqqf>87Lsa#pnjCvb6RWc~=(dt@wuN6yGDlVkA}74QX`YEyN(F-8J$ z`g#bC1|L_FPQ=Xxt4YFbk0mNpN>!^G75L5Rk8As%9TxMVCYOzQ-KP1$@sEz!RygX0 zz7tc<6=S3aAyCCHdtF{R7F~Yy^^oV!`d{2a{vjCzRj}YT*xke zEs=Ss7jsuvM#IUwXizF>Lz{9YG?2@x9?<;t#u z(Oi{sfW@bpm_Ae_KR9J6n9e^d2JMfdnpU~Vy|%2jiZsQ@jO>e_Z##1SU$%*z zd>a?oZCE*_31wT}BWjWZb4La(w*0fKkRpv9T*HY3b_L^uEy^cpNEIM&OZ%zicS?c94HrQex5~)+;Uod#u>a(3 zOloUxXlPeigW|0*lY%qy{g-D9j#x)K(Qa z%lFhs665mHb3?eTc(0LTRf2AQ5YV0F@;;!Nr^Ovaf2RS0)`jrzixS zXU6wnQqhOUM-kr8uKJfq`Ascy%P{b`&Z*uV`>Bj-&@BZ7{TcrWq`q? zGkw8(H0UKo=qW{qh*qxeLdM)8JCCX&5yK{nG`3Iet0Pnw-a0@?W{*$W3&xP3mbRlt zGs102crTB1$gs(*Wj4-+5emp%Bp+4f@?^XDuLy|?*UVVDN)6Qz%~k1FV&ZSC1&Xwh zMeh}20ag}*sUbIU_r4=CVg=(9#Q*@H{y4 zyUXEEO#c4P4i@kL)A!+2h?{Hq*~|JiyFMo;)IX>9B*;;i?sBXSu}i`M-~dng_N15d z9PfnQNom2Qvt!6EW8`^om?$Qq2a=GBe|Y5fqN%LZcR}|lxyweT<>3N-_Y51~nhI0W z#)={Ii}yXA3^zZY#R~HGlelL`=MPIA7@xJu)gtmDK00L+#oCFpF0CKuY4ku?{*l4= ziXSj}jfuM)#mYqvQ*Jgtc>y~4iEtKco1mzO_Yd|)qTd~kZE%4qJBNp9mRm0y5yY5+ zI;_humG=!~DjGtoL;~(;yQ-Re=K;8E2A8YVO-*7>+QDm87y_ToqC~Qz4w-E*N?%s} z0JFPn->@>Ir6spYxrX z4U3%tARi+=CrOh`_ac_ytZs?|{gDHn7TY?wVL~w*4>Pf7F+i#-mlNn%EteCe6kNO? z-@SFS*NQ`!r>F0T?mtT+0ds7ArTJzBO8z@A$j=t1fWSS)Cy2cP^%aZGmfC$ zHcuLuL*el45)HYd9qI@b(G>-+<9*8;&7c$H5r{{fu8it%iudT0KV+!)kHmMZb{tzD z`T)VSnfYFbjKC;Zy+Jrdla+TWv!(-#ag~8W+Uva2* zb&G~Z`zmJs4%Aq%wxxNyzqwSpAf%EciHedy*nC+3Y)p||jehDP=8!%RBP~u2(WJKB z=0F#l$3agKd+oS{X6i#>%7N`0OxuylXKOVAm_5fKy|legTsVbb zL3_{=RWJM_La4{XQ9>NdLNaW9JM^2WUX{m&TtlYcD2xLY>wrxtGIPKdQHM#c*fV5Oz>AHTse^qO@4OTi)bPRD%&wVO7JB0SH7xz_NxNyui zxexVTw+GGXwQ0?mFsE$+frM*buxGvfHXny_>+ zJv%xpPUwK5Jhp!pD*96XVS1ww6(+9L_M$vEc(Ke$az+0&!erovX(fbAo#cuEXkCaX z6M0eM*_WzyNr_*MwMVgm8=PM44R0V!R1p32o98IDPJLxuA(&_~$w& zyFzYNFLp*z0L!R_e&7}oq;GDSQ}>{x(xKWOBspvm6gA{+1P~Qy|U~42(0u$gb264Q4zi!2BTPb+#Uo!GZDYb#rbfPzKwqGbf1c$*48iL z87StRC3zwf%t+FgrO`k+;&xN4#aCCbeE!9n+YWv~N)m>)bJMXunRf(8SJa{*uW-4* zo+d?inu3rSnppX6gjxFP%hI~|tk1BqwEmU00(&!Z-S`TN{?pR`P4KVLO1Gj&SizOt z(tWd~2XmDOO9&Ez%!(HeS0ZAOVc~w3>yzeEoaJZyAJ!rP_m9XMm!}@ zm%ok0FvB{C^`-c0D)<)A%w^}v7P)o`iaVFVETh45RTbXg8r0J3QzRCR15r!^(b0aQ zjkeM{(-QA5>SIhk!RLL$gZktlTZ`rCK5yybdb8W!)M1OmxbG)}keWbaLA%1I4mzzI zqw&D}0w%N3ThQhgH+W*=vY6Z+af>Izd1fr~H-cxZ-wM+uR-Xe9wlM-f8r=vZdtrsS zAU?QaNXevk(s|0`4tVA`Vjdr#R)b+`Ok$f+ME=O?K(7!^nFA{P&PbE8ALAzYDlAjyHkv+m+be`%OaC+I&%#~!;N=`Q{)@QGr38rI{ znLgg;S2Dzn!pWT*>G&v@+qyka@n)j?I*p^K=P}ZWL~@yD9h-=QX_Ha3$|p4BA#!im zoyQ1`@BQ%b89%OTn9zu?$cxZ}BJyXce4?;3WHd55C&>T?&bNyg^s+)#C-rZ7=A38i zx4WeiSqOLZzPl~xK2@no37YrM+po6=r}cMoIC{MoMjKNG3o&CCbPym^;$TfF>F|1e zGw}HX6(ZALJ`|#BVl{uC=KkVUd|nHwY0dJsab#4_JU6?SPfSXJZar5k{LL)CkYSVG zShU32?2!oUU}PGx|Mp1bu`|(<*LrY}Q8be|PL6iLqdj)xC4G1$>fC7F4~`7MUUW;M zGXOEGMBC^e@72oR;@2i*lURipoPFtPI?xhLol(vzqm&!_Pty;t9D!7n*wYv9u z>p1mF(4o6(Tza^3TY6d6+3vWny*L@Mf2i;5bq@hL$2zL|YaW!n+j}>RH&pbznz(W@ zZ}0w|$0rUeB8m#zn0C&7JG0o3t3CYYMe8J#Rc}+Q>`LWD=_JaPRcCY56tB#48@o@? z(tjscDAX%@v&GMmx9-r#xXX`u<1%S6G@t^8`Sq*l-USgt|6of59OBMqb~D^^;t}fp zZ>wYA{_!h>@fQ1(E?jNFmi;~d0y|Q>&Wzu`~0JgaK@XDF*3{@O~HrSex}IBU=zhy zCaTT1hd2V&_rDG=Pc-*4P^#~>G=fEL%pJ;rrnUAZ4>23@HJW`?*a*+qIUWl!Yo6C^ zrt!jwqnzZk(=-*8O@Zi*8WvBC3I~qU=&-6aNbw+%b;i4}+!zV?@!51Qn@ci_uL0 z*yn)$9vD6$11**nj{-mVxOrz-h|UNOskBv^7Lay1^+Nb4uLJL#OOha0&t-PCAF52h zoNa`LINjzv#?}%ER-o>OWXI4eB~e-zG@f_DkjIQZG*zAUDxc$zhZCO*(vOF$Q7Oj? zSTO`W^NP2p5!30e{uD0{$FLXFGm;(yPZt-h9HN`MXyfq<)WtRSyVB<6Qf?LYFjS)D z5;{hqe6*F7_CF`g%c!e8R*XJVGuzfz4z~qlY?o4sK9&~_qqJ(M%I{S?#Ago2mzV_Z zwFwRRhlBf&PgF?;;tm({<-nLcJEb07iI=!hx~ZENO3aTc$V!ZKsqO?`D8(;=yr5It#_X@QeD<=!W3KU+N7X9x^$yHHf}@SC#m@W=$asN-*BjF zK{sG4yIekZ=TJ9>==jgYS3r9ok~u2tc-D)SSk|Go?EW!{@tV0Y(Oi^ecyPuurt~4{ zVD0^&vD&4qsRJ7hzpseq3J4nSN?>AZe19}K8S8}#{!qI2KucOiQ%U^QegqB17rh8v zFC9u~BZiG={#V8Uqga@~fs-d!8^0K}}{8Y}KMFY9;K zt={Yo9>G-JU-U6#U(0Z%Uh^I{zx98_XE4PXs{Ejm&8>97C!r2uQ#pj|$q1}E(a@jF;#g4M(ax2|!1q^A137maPs`|_LyzwK*-7fS^G_@or z7`E)#-|L&ueIm(pfbi9ao3gxz3$CMu3)!?#oVWW)RLSyZrvX%|@A2Mq6FCc69t*Wu z>dy_I*%sQXw0jI;!>btU_lL0JwU=^^Q9`U3Z<-4%(hx1z-;Wm&KGvTN$VIt$1HD{Q z`lQyUR}~^}*G3hr$J!0l&}x*M=TIBnF`-%Ae=IrcF?*ZO0eR9^mmj0r<~{497GeqT zFEkm+D1)+%?~AAll0Sg;hy#x+i|g%o6zJ7mzRGQEJ`l=Sp#E!YPEz#YdL|lfP-N`` zN~O#IjeDxVEBpKSf_8*Odj@*+8Yg<%3CeN9o{P`fkn@o~p= zhLOV|I3|Bhpw9-HvCa>!4|LxjgNQUSnQR*ln_I7s;srzYu{VN=-4&-FG?Bmq(;;&A z25N9es&bGHEr>XlRFQz9OjWwX;~L$;#7Hc(AbXatrX(VLCHh^ld;r^;3)+Z0`K4EQ zT6Uw~7Ekok_3h5|Nt90H*hLCKm#J_7UJP=kR(qxvu!=wWuEtG0A>x-Q*tJmC$h(H= z_ov8lk*Pg;-9hHiUA8Vz{Q=vgx$+SH-c(pz>GV6x*Sl&_ z1Ps|amATgeq2(&sU@;xq@OL=fx7RY)|NPo1ZCzg z4|A67FGI@5SgltZQF^YW$NY^%AGc|s+EM@>k^#D!4pXqe-NBHrbV`_ zxPLh3xQ@J*6pS!^!x0RVOFFp2?`agT$LZ+_vUNYY4usrPDyKaDnUynv#zJZZz~bz# zM+B~ubF3!nDyn2j(`C41EVwxyNy(grY}XCHX2Te`(BJMDVU)0ddZ@@iNZk2CgJH04 zN*Z`19;Jkw5p)6>Aj_%Yo&Zb#gNf!WvaIR!fsL04HgXBAd&uaRLUZmA0OC^#P!)x6O;NoT#j=!!Lij_~!>=`rryEHi;FzWT%ngvE zgr^q)%d3t-4xTCwo*JwM3j=%@d<-;#pz;xER~>Y+9}<{|XCy^u_5475l))$A*$Ygt zrp=#ke}Fckvm)G#BpDDT2evCf1-Of1e>;!wFX0?TCs|^zmN%L}ffVosvQrzBsnVVQ z)~dnq_0=wE+Cxo1P86bLev5O|6Wv}$>A$hFvb8#e3%0Wgx3jXhP44UbGD^{U%BFW% zHp%#}*OXcZIczAwljq^(d+WmEO*{|U{^oGyzSn@}#^cA+#KX#)pV%`K8dDoSz^uSu z#nH`d;ovD~<~S>jbNB+_9)IPGH;&fzsqXqk!NyKfsJh9WS9*nP$wV4a|7VOe*Pv%R zR*zvXJRx%PFt^9HBvd^F={wFZP%8PjAH;m@PA_d#8f0cQXFwS>#hFul8V&i z<_Y4(<=k-nU$4cm;W_>04`SU2lV!-&xeAocd^Q8a53;(ZU0y`-wC@=w3m{z>$5SyZy^~ne4aw zOO9Kcp73)l}a;?`G|8S38z@lbpYqVDVYrRKou$qcG@3%dVk$+)p@vAYh ziKU5!wUwo?KyIGz`?7mgA)+erM-{?hXFO9}bs$HRl!QR-2?-X?9}tHaY*t&pUo@a- z**DBsJRN2PZ=m}`9+(2x&~8@M9mtuE<_7 zT@p$glA7Ch-zo;|O}Xgf5E@?H*ZNtuUi3Zbfz#)`l&ITh=AjCWuv%4cby{cE=`tL__;2kShaZYS-kzQ)^C-G{IXc4HMe9D~2y{npq&S8jjd zZ>V=@vJ3+IVSIh^XA1kVOYO7v`wIOhO}WvCzuME$XN#-aZ`_dFyxM-v)`pH15+jdjreskoFfgw|8@$0S{m*;?>IIX8Bm)C$NiTsJ^@7RCr ztD^IZb4$+f5b%rRNaBn*#n{+Uk3~WIP!9pl8nwbh&R}Y(9il$eKGaTW8__q~@?X=5 zHc72)ZLy_U38G2tup`#94O=1{v2A`XtM^4DX2l&gWRQd`G!e-mRZW3ogYta}TY|5D zzE@4%^1v)YEjATHLlNx6e#?ieEG>~P6WDOms&wM;Yh7PZpvACgj`ez~@g(>=jssNf zQX>OUnpWW?z?Z>S&=fKyzc=x%Aq0*S>c8=hWH(NS5%35+%es6e7^|JIh`+j`{y#Hougphhu}&A!%>Sw3X!Y0GLxP6?LLc& zJJK_}otzS#96*9j+le2=^l;41%M9O1lb|?wfs1;CdB5>IZ4g#`8t?-T(UF1e zatP0i(*PhV^BK4k1VGsDjb`?h~{)8h)-n0z;!`aZQwxk+MB8 z(LxBh3%vHvoH({dPY!ZAUA)a<#@M`!)E&M-zACqvUVu+yP4#qPWs0v68I>_OgFq&W zt^GJ*2VpHFjO0Zr6{Y(8Khbx5c6BT0KHcsyq?8`1m zBDM-?BJ5hrJ=bfoWe>FIPF!cD$Ry0%8UPORTO6U-&{TeBb6vZZ4&UpJ7H z>HTH|2(mC0`weIOXh&H+ZHA(>tw8cai6~hwg?SkJx2Xx5QPHyuQMJ9e7L+jtCMwkq zX71OdOSmb&LxG)SKD&1Zz=BbgvxC#@xZ=FIw8my zj^gUFVern&;IG47^paA~2N}~8v8lHgaGwzv0K$C(vUW5W4Z z9G57fn|0Iy2Rn6}bxJ)%n{}4GW=pKgW@?hl&{;-aWoiX&*!-}(VMZco*+$5`BMnRZ zVe%qq=@40c^mic>f;a58Xr77cThx!#U7s}IJ%qMUM|krgspK;W4#7>CzUek5o7w^B zlV4vyJC%Nu=W-RU&zJNs>0N)u)JSQ0L|lyO;KD1r^=L)Vc|kluJ#YnUt!RDDu?|{w z9jHKPYPKIzA7S{}}ipiYPisR0Q!)T+&FCt+8^(OGnzA{1JL*$=K{k&~=$uHDM7NYmc|JoIm%@_B%%wNY;Ny-q8ZwlfMffI~v z8oLY*KPtSDB~-;1)iL2|PO$;QHi=QjuZ}_6vE&V_rnkwj2*$g~|H{7!d>+8OEML1K zswncpFTuPN5x8v$th2?rkl7L0qsuP~D?tDKezPTT`i27Q2dN$+wh6iYiS_c}Kd}ut zU(|+5k4TS57pIo-kKnx$1p$uY%KYQ z3CbG`Ga}pM=dgegjBXk$`wau?lP0sWFBoF27$+zGE>f9*v2TS@DZOrXjs`Lt;wQE< z#vuPWL1c?w=gRlL0!^Wi%CW`m25IAO<39n~`BNc%Aq3&-rjdLgd_VbDFNlB42iC#R zA!-xIY^J(HvOd3wX{!AEgR6pbp6!UEaZ=rrr_9}nG{M;s-S#oZ%8U1`XPecB^IT{1 zA*i^n%b5&O`;8fvc|@kqj5U??9ZVGR6XS$H6|~>(cQ>$hhF=Uv!5dA11$ievNdA8q z_k98NhC3yq{Py*cK^aE%(m;$lMwRh^dzuY4k@+=Qon;U#vOB^DAB?ZC!Fse|$~IiS z!M7YKB1?+r=#k-n5>KUetiRL0`G1*oA1KeYpzO3YAQ<4k*1`stn5$1wWl|#rIH6Ku z2qw88>HA44p!?86FIs+dtOPzpG7QVnW1?G!H}}#^V!UGHHIRA3{g(^_G5;?ET@lrF z%%E(L|C_*SrR>kZ=q3i{uG$*H6xe!r^>JDBX^o&~KRWfd~KExehe8|Byjh{Ol28nWq8Pwj6PM$S+6i$I&*V-j{<+Q=W)*s=+l^3NrX zGo3}G^U%IJMP#%YOPU5Pxv&tZ({*W}y$uGN+dszLW7Jy_ljXj{n}gHxk|05odcjHB z+_Ee!Sjupzt}C5iCcBwj&aL>mV~6>f)$Q)AdytAp+KAc=;on5F#PZ)KbEua+`$L2i zxxG2?%|T}OkYzhW|7%=aQa&iV1L=fjjl0{uOQ&oimS0dZ-xDF;I zO4#2E6W1>vz-~qkAB05yZ|(lQiJ(Y;Sb!L*aV$)XgtTOvSP90fJ(SY__`(SbMt1}ev{}q5z8Z1UEo{i@e7yMV7bix0Deq)|6Mf*}!5E5$M1_Cr{+y=Z4 z%>T!*2r}gy@$&sZ&rQ{pniOh&&+9^a)ZWS6}i&HSukCq-Xz@ zheGSlR1y0b;Hyn~wkpG158XqCU2qSXsmH6jzO#CKJOqEU*uc);r*w4&qcA;*(y}Yi zpjdDHPdxGZM3(lX?E4O7$5o$&lg_^dG2DeC9q{*)6$c4o^2!aDtnHwaw5<%)z!NS$ zN2EB;*bUxJ^Wh7GxT>f)n+j>HhCl#6@Z3 z=_(t}@*YCPwp_*aVMp23ts{)rT+&R+C5L0wT5ronLttXt!8s*#~1FX3`++DZ1C5rf3D7H)9!LGly=s5rCiPOdn zDPYckDvvAuS{e6Rp7KsfRg?Pi=1Oz<6zZ?ObmE$n$Mc^h7}B!IvE|6m3^>ieoJ)s*CwmdUGfVTY%C0$=YAbw19F z@QA#B3>U`pm8sD}{PHSRNZBGqW^qTbwVHg`?RL2HGe+>$4^K1-sfh=9g8;9#kc1J3 z<4OIpS^Y-)rHT2$8L`uzDgW6}OsH8*Po~+FxnpWcA(}@l2owL#2E}C^3-WN_TtlTs zN3S{FezjjRd8Zq?k^kLM*8!}K>u(pw7Gv0lRH8$Mx8{gTpVM~CszlX=?^#PNxzDY3P{|w;Kvd#HI0*s5q{zWWC?rsiupnFjVzLq z@hOD8LNQ3RbJZc|S!(Vf642Ag3{icXdW1$L%U3JK?}_FiWX$Qw z80`JMnL5}jL&S(mMurPZDK$EgjhGUxk#q0gL}J83ZjcsP9GNuA+&EPHAD{`&>Qv*PWMe*OR6~%TfV-9 z$_PICiG%CWLHD4UR^#52IINfKPZREl6G|hh1yfFI|6@)@F-C~cT(6(_M$tHLB_uo5 z9VM0qEt&aP9u8zn7f5lWE*7nhc@y5ySND$z&9P&M2pjqntyhBcDpD?3PV@kxhNhno zQS>EPd9afjFi_ty6)P6}-zW^o1z@2mP|p65`zx5Nz_K^-ncY)^Nc6OsWB@@HE)#>B zA@usJ!3>;PsWIAx@S?^pE43|b3q+c?(&->5vgW7teOOegsla-G`I`dQ1IO+24Ytd^ z;{G4G2Yscru>7Bmo+_TGQM3i7FM03XhCBGc9UW!RYB#-~9^~IsgHk;h1lXJ#hFVpz zfl149+uG`nQT50F#Jo>Z3QpB&Z!57y)KAwlKQHvy9EOEKJZ!Vo@v{DP%e$)%d1sJ^ zmJjL9!DD%j<8@5%bIL`!silz$CMnYQ(Kq2I0V9HzpuPixl7N#=klPaE7Yu+kLjpjN zut$F=Q?Z1JB@cm)gr!jX)Bb6L(pnFXGZc-Jl)s4?Eaoo(OuI*huFdJWL~Q=u%+yi2waG+Ogfd?qu6!t{`B(zhr3otjvn zf})?S${ws&_fDi#;$K>{Twq*+TB=p-oU?4SbI!8%7s@>RXj%4iYd#@9gKN4%Cbbej zA6gNqzv*b4MA$|4A!cyWvvOa-s=_JXV|&Tx4ig}Bn3@CdhDgjj5J-@|Y+_f2Wr+)@vh9>*y!PII($(sgC z1?xLc@$Qh7xDX}?wvSLQXCaNEEOat?UQd1c-ho{toh)_sf-@zSb9Tes(NgmKY=?bH ztS1G7G9GNSEUl?lucJ4A2r&YR*EX6|r1kr|R0BED9}Q-kyYQL#GIR16t%jkTihmPg z3rQLgB~R)0#mHAU!iPike@Tvn!T9WisPt(+CJ20USdB4fBq{@uybleL75P)3gJfsG zxKTKnN7?i`v!7fhat|C7V`d+xq=HWe8-ft&KfCIl8rH+-S#C7}8e6Cw~SP#R<{ z-)Jf3A#j{1&55>KJzAwe2B{~5?`05yM=k?ZqksoX2t_DHBZNp91oD*>fM?VP`5@x9nG+geIHfjcC142mPu9sinS{wqK^3&x}q#a^Hu&`qKg ztVq4sYuj>)g9%$Sl5YS~G~y|PUV9_fNY6D9K96T8A1tFe@xCr+C?Bq&L$>!lW0E7{ z(7)L=Jdt3ahL_)*QwIIl(sG9%IQc*7c5~4nLKmcL-45Xrd$OUWp#B3HOMm3jUxInR zOEtU{K*mnm3EQ+HN zP%<2;A|@avD2b2FAdeC#%gTW+g=P2ZTS-W60})?IM`Z{Ja!47>kfuqTQ{|>fKF5M$ zMS0^&6Grl5*`Xp&{;iX)yxB|z4?%Q^Gm3ihBn6J_ERI_df7($MLi?N^JTia3DLnzMn&|uI~~?JH1^%JY2=+yn=8>a1Vxrfor%bSfyAqr<&m^RG2f^wa>o~ zAV;Wmn+#1wGgmJ*t6t4W{AhMw=l`#|*Ys!+mYb<5MUBWKEJ+BTk>4X0Fb|M3qFhs4 z%8;ptouid9%30o3%btjy@V^*=a)gH_ zB{1t`J*7KB3xrT8(NB{qRU;;JJ*t08@Ead+|20F?cbhAD+ZrGFM zr>-rZD3PlYycKK@{qD_tM+qrH_oqiUAm%rrZw^|PL}JL}>t}x?J!E(ZD1c(~ulBe? z62`bYg|rv=XE65etq8Ad!=8B9UNB^PJ%V`a6>SQ&@!aBRq8l1G6BuxMM)&#P)SjxI zh>6x|wL^J_(1Qbdl0$+rllyL!$&DGhycv9^^9=;%1K#ym-R5@hl;x;n^;XpPMT{9YAkZ!W6{zZOAAFu z5@?59f=Rs_h0*!#9vb5VZ%6*=j3LxIoPjIR+Ncet%fniAWD$DdZBr4Kws-7dOv{7o zr!rFb+)MTmY&K>UDL)fI4{csTRjMEN^quW7JsV4n9L~)UHTkZkxPOmEafH9(ziBev zjO<1aVpA8W`)}hsV$Ub}nETTD;X@N??&{sKsf`5eXNNS9F0t5a$%aJuMs(qKSS|Ms z&^A*jP`g)b&y3=X%Ib?{hc!0^S&F`d-J|WH<8n%Kwirg($m&FZ&I6e&K7Kq?mX(R) z)#5H9@Zd{(&|Fnzipb_%o)Tv*)`?i1g5~%}iFrj)rJ^NQm7Q6>x=i!!J-;&)>Xn(S zA)qUBHpQdr60q1iGu8$;beLF4s;+b^S@I0LC80i8au4@FR%DJP(q8Ui|GxXKD4g#v zHNh`$TbQoT3o>867Aw)z%+E2*-L?LOavejqd9K6h+!@#~5m9y8AsadO`j zc~$S=2}E+;Wj`hFsB9g!)g!;;*sd-8-nP{PoM2w zeVqykT>C~_p%A)q*w*N9R~yc0u$V$`ru}^wWS4L(`)qw6z7|(B&)X<+uh71U5b0PM zx37E~mVVlPm3xnGNBqTN!tdzcF(*+c&$nNwi9C?(fN1tr5hLL=gFQs}cgtwkx)Ook zrPrI(LFeB`&iBOYlthsK$m95Iy)E1uKy+97D`w9E21}($D836T_l4h#+)dlXQAcN` zx;*^+D#s7;{}OdATx4@UUr;CP#N+Sy)qUkf5$+vNzG15FXs^RP-R85E}%`o9eS&>QaIv4mSs*2dtS zvg$+P6_!MsUf_^KlSJ$GW)X?!*426?Ea8#2ALyYhmB>>s{y+&!qqOKY8JM*X+Qv)* zLa52Net=i6(?I|x4KxQwG>A3Fd;xV@3s>s3IOq%`%izdBb`zc}m7eo^FSRnIGN*<+ zuuM%=@|%hOV@|QfX|YV2qzIDw)c6eMBnfiU>F2T-4&F%|7ySGnbNB4=Tbrt=LJ1*F z8Tk@5ImzlBI1{*+WQ=?>`9q1ek=H6LDvW>F!~y-1h|R|kxn)5F`7WZIu>+wHhVkg= z!&ngYflcy0S;ZC=#KFmM)F`redy{3noZ2*pGKi`Sj*;=!?jz{LvHqCHb($+*0PoOi zKRYBZU`rPQ^$clLXE>Y&KP$ziKkbnC_CtIHKD2x2Hmj90IAvUx ztY4H)w`)=-NLdYGgnESf!!PVvU5LedLB{?vsEnyiMBn#@6l*ah75O-Ds2-=yeZNIT zVlLdR5(K*!rQ$+zhPg;BTZPH=u|lA5A67B*15-py>gy<#GE?x9j6{$99GL{lKMrsw zzh+?|Xhd2B&8K_|>iZ=nrvUo$+amluyFI&h9@KeG((IYHYjWJeD9f1ctdQXgI`YQ#ITD(14TH-hRTr|v zUGIQRg4e^u?a6F{Ym!bH#MG-j&;mIn<5mT(s`{z5;7f*&vRh@LM!|+Rfa^?g(|D>9 z2}-oiJc1sB9&55J-?xNQmlj4Hua~;DZL9*or6!wN|}Q%_mn-jaU-d5gKuixsfVL< zwJl=6W_H8RDL%f9j#)?lhPM#C5d9d0@XPY!n*0pL@wljG)NUk%a>><`gqj4AK@9zT zjLCDSA{5kYQZAupVi%jHhSF}dP|G;{gh5X3j!NtAoJ~R;NDchy*9J1)<0QV$;{qts z6EK6|B!pugx(Tav1)wz03OHK(cKD-A@-)o|=t0c76;hS2=?eTB{`=vW7DN|jaH6?5 zCcgDu$!vh z>I$19$%nyRNNj{P7uwI?#>6r1Hj486v7KsHxEA&p zsr-0tMIbB~3<-Z4?iBhtF2$TKqHXCn(bp^5kQ8%S?Bn34=?4e74G?t%9fUbCa)_w# zH)1^ZuMeCpFWEGqydMr7E$oDR*fx#~tTT}cl~&g_YzE||h%20s3Xux0JTNHiHHVc6 zRG4x&Hfc^=G%HVgnyli#s%SjW8@hkQoQe#O zr;DtHI;M(F&S_4a1$Da_baZZ^iSVr30$w4tmh_VLOaMt@j2+kF7`_6TI zGlbT~na^}y&aE#7xJN>t!+s5sbHL?r>H-JtrDeHYhg@=%A%~ZGW|8ackDUY0a|G?r zODa<%emZv?(cAH*!Oc0@Rh6G@JAWh53-uE2bO^D5)W=r0qs$YXP1|?2g|zSDq>Ax8 zoS#%IZ0KZ{oa5|uN2W)n>6qM7W*|w%XtHZDvIu?P!i74-`mu;rdf9EfE$w$cU~(dq zcU$<_Hki_ffi^=;f%?S21BpGlCbmMNeYC|YtraExF99@@A zwjH$Ne_T|Fr6 z0MvP8UjfHPM^tm<r;-~%AI{>`Dke|z+9##`%aBbs#ZfA#nFqFu{8cRbyP{qc_sCik3(TwI;hsW#ENva!u;j!?G^ z=x#WrJhu%t)mXRebCAQ`l9n!a>L!hCqT5CbEggz+H4D!I*8&&BL9(7Efl8SsPRz)b zRUzjpQ^yx0yr(S2AWUwG&Zftj2DViuuQpr!lc=6p&jl#L6AkeZ+8JIFa`JNWt}MKq z9LyIA=4@}5Io|dEU;t|A8kD65)_Ev9lg-JZ@i>nwy6Q=S92^QLy>gB7#O0lTylTLx zpz-j|FN(1S zil$3f+(KF|nDFsJ+hvLq3y*CKTg={9gIwcpQhl}3@Hgh=w?qoKf;bDf{Qnu5- z*D4qCF|U`+ZN4t^eQLe5vE&TjgoeZ)0;&L=OCAeeb11rC@1-AjJDsu)Ak7wH*BoNU zwK_7ttcNY7X{mzhY#q-VZP&5O>~6Og5*t2khMg3~x1`G_FkgI^^Sm*auY~1)5XX96 z4ViEub+b=ewEf?ngzwRK?!!oYX>icEzaY{p%u%jWYyM`Y6K}FN?mNh|sxG=^QY*ER zZm~@(IJJ_Gd65qzu(&N}(*fEU+F9s|IG8WkTLs$Lp}Mk`uGTrx(z&6HvewzVfi=~< zH#?S5FxBd}Rmy$JL+;d-J=XSvqOYcxbNgh``6hI!qOXcC*jH(*o~;7w#h`i@V-_!-#n_w!UH2fP&F?Ed3?6AFuN{ z3hT;4Hdt+pWr+lN5R6E|wjYn>KJ~5?)#`B1W5<87YtyzSB4J6{qJyvB{8ARtt+U~L zA$7yhgP*wMj+>uM|ND8j7T*CvOjx&f@N8#&cR zA9v8MQ%!D5pKL@DUX@`Rnw?;iPEPy#^C6NtpSHB~3Zy(uHc4W~)S~){d%R{* zX_U7htWsC7s1+I7U8r5UO-A+%s!+273AarEZ5>S5h*&^NU<>__?y}w$L49{3Ug_gU$IxU}|o>!!xaC@4W%-r%?D?|{MoV4x^Pa&ECsQMq4pkSPf18F(y|spZFl2!|r^OPxa2rVj z)844TY51i3XFyYg0bpI>Lohxm2sOHgf>@G|<_PkMw9MH#f@J)Bv@<6?>?-)=%!g!r zZIhCoio2pIlsZan6E`&0$5F(d|G|#YRpy7xSnR<67v^GU&wpcrU&zw^7PpA@3ctzm1S#ro-2ct88 zvZgN($zZ?n&p(uHvq8i@yDIgS+iX^@2-Td;{}j7?5$`{|pu>3u^4`WoLvvY7KndCD z^+32Wzg$6A5A3#3%WqE~{HIBJ&%6$C>ZWG{J>fyM>XrFO?k@ezGY7RN^jWg$_)l<8 zPS%buQwA3PxMl7C7KE8YGSAPS=IUsU@lnhNWJe_d5origb0m8TJtT6&5_u&}3L>Wl zVU_8QzfY~Hs1nV0jPW1L?nS?WG?H=IuzL-Wm#-p+iFdSFFMjZAM|kbv^BCaK*~-}J z+|$J!sC`k(@YK%bLI0}v4VUcI^rQ~Ev8dW;!4faclbWo}nyhWne(nw3m3Rl}`n}*8 z&h_(=QcQdA=EKN$lLz$C?{#pU^}uXVueFa-avoby&9R-E9vj!-rnU1<5DOUb?7V>C z&udH9dA&i&lUihH62h{1$D{c5!nr|wD~>}knmc-R1)7ApJC1t%$gJ!y2eo+krc5^? zcOnTKm6fC0xH1dSSKkFPHpb=jBy5={UsAi6^JCSB@eV3 z(-tudylIq$VTAA3^omx^z06>0+h6TsBV)emgqpkz@YFMy~trS_19s}(-z!fThzjOcAe zHD}cv|EJ2_{=Tq(9iS*&En%c&iz$jerJh~QxdXc=urH8PL7eTWx9VfHSg6i~`9F=O zN5O=Os{>PiJ%^F6w^Hf&h*FIbezj^=n$JN;n&CA>u@;FZ&76s2x}B6St{WMZk|?6M$W*RHxP+gDMeta%5-wxSu4i_qQ_qn84$qOP zo^i~q1d%Z-B`Jh@(mo8xp2;Z+NA>Ea1;OV^%dBGL@)TG@pVFLN8Sqe8@#Md3VnssW z1DZPAntE zzAyRMI4=qWScvF$eCeMvrnivM?JOE+VTgj-Zk5^Q9sYgOa@*qUjdBYyXrP@U-%Vyy zb>S;P-%VP#%V}8J(~f;3gwo!jO|%8PYWN5ht{!EsJQ&;EVCtIM=vHEMG7g_n)vtPd zm!yw%X}t#%*}jK!S~HP7KhMRpD+)$0!Wyxsb!DP-F9BsJK9L)S%=ag-Pe|IsCS9fa z7cWBwbxy3N`qL{=i#67xfuMA(Lg>Dj&OYQ@=pdA!*mO~ff9Av6qGvx`ob^@^O1w1d zupUFJKJC}#qaSdMVC375J6CvHE&Z9MNG89X7Wd^PhfEmShK=2O;P6uxepyQpcgEt12 zxn+Llcy6d%P4CrTdFNBFseDXlz%z72cp|+3*M|S?TVJIMjSkpEO>1mFXr-oiR99BI zj?JryzGZo9%2{B+TlGXy(u!?ur7RnjG;^*z8QTo%Xr+~NR2N2BL~>D1ShW)+RAIbS!%g%ug80#kb81A=!*HzFNL0jKkhi9Q)0xu_*<4h zS&|TKGU&!HlaHp7^)wM?*Qg!)Ue;v6K9wsbo24yE>2lF*rRs~S+A&s&ay_os!oM{b zV_*}UC*#l(SQBdZy0FGqIk>|t9q%Xy8n+58bICdG+xU-H#};m2_$qrGc=I+vW!vf= zJIT~KAllAEbBYk(lkF>%je#z{NK@Z__;m)et$4rw@7@DlxN-7?qMzRr!uxG%sT@VO{c-l( z%_}&_-c39d=5-bN_a^i_;5X5fV!HF)o-8)()B@`4llTO0jd=Wv1<->qPw9#<^b=v8BMyraH`^xFZlq2*a^hU0X991_ zr%O8@ZzFetkVW`vZ)dE-Cfd;6m4m%Q6r(XHf|$=b33@qy0-9#priO>k;;rZiM(sWq z(93=&=Gi23OyC8L=X`z?%Gdi;oRI{2o5| znD9h_j@VN{nib7VSHAf0?%)2MOsch}9Z$7j?(K+uVpdVn$*;=UTt3K5!hcZiZ+3Y< z2SufH-tG&1dwBa$zOUkKjS;SfT-k=8p}&$cc2S4y^itRHQJ7n*&BO5FaWL9txbK++ zuFpS<>8m5hDrWKQ?>}t!_s^l&_km9{*dGHyZv8z&i~-VpOh>wp6%)@60i9poo)3jM zgI>>9*8(rM1*bpI5|48zuQ#TLwht0diGSZkBSwuLBpx8XoURJtU$;6LBo=j37$oM4 z;XmwtL9z|v4%~98bp$vzC>DqE23)>|@H!DVHuU{LQiE0-q6&p(XmrPd6=em(!Xi3= z6ah5KTya1OzAy$D#dUaY7)Y?`^#)5Q+KL%4qxt16Y#K)e7YyW^|3i^KOEjq-7641j zien#`A-w_>?X#3@7x;|BOZcjoj4&S#CzM%+h2uA`6+(qEe2*$a=ElUNU202KZsGnF z@rr!WKV%g~+ujL0;bn>rff2Pv?YL-h70 zmkNgP&f(_a!eX@f=D)rKU_HQhnJFT)Qe^NLTS`U_UTY78p-q=-8ynHY<0CGiVbht;CuXR{ih_NUsKb$ zsRnU$2Cnp1{D6;Wg>tkss;?`0=?V#v{e&_W18`a|`eE;)-oG1~k((>(#nTQ5=McvP zOM)e9+U8t$LBBmj-dJfE!Un5Vrcn?HD1fMZ;RfnR+=?=Yp(?>laUx&Dap5I!QTa-< z;jEC%kj;>P&C*&SO<*O_wj{*l1#pP^i9Fp-`s|kqQ*O?y!$E5eP5||A@3)Mo$JLwG zKSLq|eLR+B&b)%HD)@Q)%=5$dHvi-mS%<`nl!M7k3#3=LU~dmq3@r=C0T&me*m2HN zoy5H9p8rQ?w?6^j)#=)*A_LU|?<4aMln(qcGOG@Jcqk&CYO^fF0(b}!lYQ*(vGKZp zRT3zP9&G&(vPOs(eSI)K&OdE&yK>xwyxopwoZsDP`zgq@XTFnv4Eg@jUt_e5kOAK- z=)B$tYH2Ab9VH&(miKt(S%s~xh{A-ghLqrtB0k3mO4(z=)ELphV#V*#SINlDN?G1vz03SeA+O zD>U$&Jg0{W^s0h>(022aO97u0KBKM^HgKES5|H>0&oyAo_=0SENqtFX3<47=dhLMI zSQ*yC6E!Rp!sxyvIAt7;+LGE^&nu>ilRdnBf!#?(B?b??#*%wpPX5;pd+^^_K|8o> z(b&Pbb@!2j5*MhlnFF&N;<)NglA5SQz8OLeCsgCFmkH>Ly{ek14EQVey7n>ZOJxLR z82$)WO|;~^w9E@1%rNLuS=&y6^C6+%lo=IWtFPgLk6SNUP-hq7Qj;rp(Z@cVEr+RL zLyMa$po%0M5o9Z>L|uup?uOBxf=G8qrZREdpe;t|5=8-UfbapUF`?2EQPCFw4glx) zh4P;P;NXQJ0dRB!Wkd=F+5=y}B7+Q?ReVem?qx{fMhgiS_w3Mr z(MdlE4l;Sz^T;wSm?whF{b5Kj;5Y(t@Ztxa_pmRpvw8 z%U4}c4YZwJmxI;7Y6Jy{;tY1F3f0I}5;I<^_SzEFF`abMrV{iS!ph6B^YTlmJD--) zP|YBe1wxKCl)qKr7Z$>$irU#V1_eq&d-3_3Ot9vFefi8ae*> zA)<8YY1Cou9zQ4a<8o*ZCk@=r#4SVH&b@1&pwkg1kZRB)O80M-9P_jd5^Z#8yNJd! zO@!aj(nA0l0F?wcYK}Qrp5QQdo@zKCg48a|c^q~M&Mpj1DB~C(RSB+*iw34qHa+HOe&*48Qm9$y-1Ah&=9;tOA zVgp1TDf~>79?biP`*S7eKV^@=<^FrS$^LRxLi%WH*h}3g+T-YG$XiSKX){OmzMLWG zGRARhiulGwn4Acn2i1R@)e9jN2nBq1*8QqRs7`;2jMQPLl=aM;qkN;G{R|< z0&qR=N{T|S^V?`5%`^$1wdSXaHeuw=GzZE6C14d!i!s_)R*$e~)%z6=Ur%U=+wQ7T zRZtSFKF7`oZ1lGI(aGWS?fO(?=k1`gC3NJYaynFRdG)`Z(UdK>d9DfGxla+h(kxI{rL<^t3P zyIs^>)UhI$ZJ>A;V6K1_-iu~A86s&gMBTKQ$Ab}o5eStiZy8-Dz(eCM&dI7K`7O{# zGJ{$Wx5>qA_eC9M^}{STUtkiW0%w37lD)Vu2_!$J-eo4lf1F0MOpJ*fH-Gcg?tC%; z^)dIwq&hNmKAw{+dtCmH7qKOwgeDjc?M+Y+v+F$15^6(8f!)@v#WM}a=5YTTq6}76 zGl%9fk0vY)hnGe>&J-U6q*uTmDt|)Fu@tZQ*Cm(|e5}#qD0lsAna8X^YV!NI^g{#} zGg@WHF+mcOGJjzb6NR>T6qu7+))G!>NtEZ&QS zi@HaTYT07tnyc5E4L5c#j-xGnftwF!wMje1_mC0#FOi(CqA~+#W11wK+^|~${4Bd& z5R_^tB^`j&J4@Y{s6Mxnga_l&OoREi_^hs8!w0)$iC9zvE3jz?2s`Zg3-(rbj6ziQ z&Nr^}lOVNDKG$9RmWeFIgRTF3l^AHsb7g`dWc6X>+K>Nz&6s0)1lbzS+Z-kTK&+Vy z^e=nqKE~+RR+D`k5z^F=x+7qL<1I}fC2xl+`|nHmyDx43;<mF{_Gz7;l_h)95ap{pOz@?h%6x;gG|( z)xI4n76uOi5Q$p`g%`;R7=IH|GTluhOK!nQHDr z^EBDpmAGk+X8eq~7>O3o6~@jY^G3bptH(tMl-qLyxGxjz7yN-0wn+bS4iSZHYo{Am zRn|N#HsY!9*)^G0pme+Y!~2GPkqxObC((ux4p}7{Q$B)^ZI~S|`2yP&4jDxJL0IPs z74)2tpNxT;ss_48Dp{ph5F0prVGbG`KG;eNz-yV}Kn{d&0klxu%Eu!Xz~zfpzJu+d zmO|(Vz<3QT0M;t0Qka&42N~;mTL8-UWegS+J-mONr@;j7RmaD_R5zyC%Tpyf7b2!H z@^P0xJ5zJ1Ydyw^1qgXs3wA*CHxX!KskgLlTrK4(9DT49R!hjS*I!!te7_6*Rj#U& zHbkQpZf^kgSH4>tt8M(`xMz1dEK)178(!+uQ>Dng^hGCkaIjErC zDN%A1 zV4MN}%W{5WBa9`Co)jlFd%x4@`z7rxUz~xd8JeM4{F6_{I(!GIc1?NYck={?5~opl zK$s0NsyHayCpM9uZhW)&n$fVaH?!i$XVx8D)6q%ZG*Z}Qv8*3`=cZaNFiRmYt8yEY z5&&|}8E0_f6o6c-0IZ=F46SIMi-Dpjp`<28J+D~^EWoK=zWZQ2T7iw$P~4(&sAwUO4Kk?!vY|$D*|D~Rrd}@?brzoCPH|0kR0dF#F!;WVGJ-iz zF_GiUd)rYqLhy(`36eL#Q5#osHJWz9SOXvsd=?Jo0&_Vm(~>g`+t~)Y({pguK!VU$ zHmX0kn3Svi^UBQPSj|v#tWT?EvfBuFrp2HX+8Bd@EEo0R;trD{a`(9h$a;dJ+FhtA-89Hf( zkZI+6y+&=Hqd5*UslLiq6>&l?lS_v@=2~%^={o`?I_1Ye9AZlJ%5AR`Xhc`#5AR|8 zsCf;;A2GLq+gU$#R|3RIE6FrOMkGr7?dDxQH z`EN$LA=nt!-fe(N0_ESd1h1qjq>!Vs57L|TOTh9_+5M&pP@U|g^c|V2xei}FRzxRX zkF?*^G9`^;+;bAUaEuCTnFMl@e(UxY@y`u7!~VXn_bB%FOV3#=nQ56?H*V7&d#gy@ z5?ry|4P(>wNWfNfZ;3v~q+d>ggHIersx8BIFfhM2^hO7fFLQYyiZX~+XbYyuj@m2` z*v*ChMM8AoGeJN!&;_J_n*JDqzpK^=vd;WGj8iw&?I#X=$kNxVd~aChv3`UvhhpJS!5 znWYTZo(rV1p|#-!WnwjBHS5TqVKs9Fq?E8IY`hkF!L}1)xH#_kM*}heng7a=5kMWW zziKwcXuOopGdR}mo;L57S<@^T#--cU5)`&vlDn)aNGc77-|0`sq}!5GC}~r7c~!XA z0<ODqU3KV&ts9SaU5HLW$eY&zJrj=4~y%*7+f#Hfrzsf;zcN<5=I2$7}J z>w+JX8P*0eCDWAB49^%cnT%}?xQN#_-2^`UxGMUYovGw_oI?}ZT*eF9{vRKsP@M)0 zDTb+5d24CNNAhPLnJqO~%PPoB(DeSa_bogWG7Bf^{0!>S*X2Spj(4X?#XG9cR7vLq zD?%FrgwJmiyx)G#K;=P5n3 zevtCRT8TC+6Hs$-A#sn5q$TkHyhhIl{fU$LT$=hyG1^h3n9Qg(0BR)8&pSs#IjM>% zwe+>IAC2(@qcvM9?2HR_!EbqXnRe}#!8TYRg z=yc)yz(^_pBT9<+m+q3!JCAd|n#!4_$UEf+F}?E5HXy{gV`d)2IoYvR9yhwOQYGBV zouda8jsWF=)Im9#C4_DEwQ6I&{H%QB3|MCetW&F!0tTXig<`WLM zWezc|`utby^U3CSzKoK+zbW5h!#{1ndyA^%trJ>W_^f(&f9AA9Y>^g{W>{cWOh^Td zy+4UW7G2}e#F!l_8~11a z;UM}e?LT1*HP6Vk3_yXoP)a;p{&=p;_p{zX0@ zYi7xxPtt(7ev0aJ=^0NnvA%r<%f&@*AlHMy1xPo#|a|T|G32;j%-nRUr!Wec8;LJOPc@vYAM39~us%$Ek*tybrU#}|i$W)89W2OcrY85s6)eFzK+$61pawMHvdVkN{;%OEy#@3&AJvNiIJQp}mY)Gcd=zAungW=Att{N%SNHjvghWg6xGHu2o*X{h8U1xFpVmeoBkv zt|8iyCI3DDgMr0x#gA7b0T*G~y>=041QI;wNi4;(uU2Wt*D`%V>1T=T-fZ$i^232) zi+s~9fwU!A2orT7sL|HrJr}1SQ13;jUBz&!yC988G|gc}js?S~eMEDh@qpMKZ0YQ) zxU1)^1DBxfqQ9#bKaMK^PjcZD3FlU$EfDdn&4{y99|_kSyx}Rs#6g^;^34yfxiwXd6%Tpl@c) zEwL0(pl-9&OPNQ;9zheb-xST>t_ue5Gc=!ls4oyG6fr?nu#zvj7DtT2hTGQ@E+d%W z2>EiT$J-Y#`dauh!DWB8{C-~p*SSSv z0Ob!YQYlazrz0(1u{_S@l+4DlH;kwG)Bh^>#N5-xj_Q~$2%RZ6rJ`#*hN zB+9V8SHoYOmJ*Z@taL9;`k3?)If1eG>8L~(6;1+E;aIve!DDNEl}Y`wFoNong+1m7 z4tJw9mL^_9FGlf#B~vjYV`Nui5l3~Ht10NIS6vqOujd76;7|oGby1uH^6zo%RO_wh z#AAvSCv8R%RcC{$G|6w1Rq6=AS1~+3rC~DULle_DvMzlK@tdZ7HYLq@b?Hlx=X@^QD`v0Ow>LbIjjE2+mgd{MHUY9 zEBIv~pun9l33{fS_}AnC{7H-#{~60!QX&_*b)O5Wc)<+9p{9pcaDccd1$mMx+#!tm zglqr<0T@z{mQR}Jhj0jU$M~V@zqb?Pa3|z2qp8ScL}LQ(?>LW0M(CmQ3NB!8?Ewq- zcZ^p@#St{!V{&MfSH#lEsu_+TskO;xys>t9`B#QJs27I2PCgIViSp(hxC#0{V}KXW z9~6Qw(p%&}@+gcEddd@++u-N40c@*$3Q?TGSQ1P6tY9WP-l%;_SR4gybced ze6d6Tg(#4mS9HW4>yFAHKoVOA_|-{VB3kwFH`EQ(GavvUsypg&f2$7K|5T8e=)zg( zo5puqRF)H<>8Dz6-$|F1d%E9$$iznzQFas< zH}{(*3_*SvOnrJ@Q4rb*j()kCQE-jsc|O!_rTAgmGvsj<1Ja%uZWZKT7;d4S(+cdQ z^8upL`C3UdyGWbQR#3=_0YeYx{~j?)Rgws8|6i>Dy{J^MlkhkzHSPM4_p#9#7;Y!~ z!~miIaxlg~WEplL3#}+mKEg!@C#}DpG41vS;;n*mephp8HkS#(Cph)gEl>c3+ z^+g#Uh67^a)`t~Dmn220UBm8j-tru?41^0lE^zZ7JHAQyl7$tP;uTmSt8o#xO&6Qn zlsQL*a*9#C2--GhAXwhg`Gt-YoJ_NWyjB~e*#E5Ve&~gai5QFH41051+;y6}nRf2N z!Ky84B&^=B;CG*BGHHzQVmZPZ_vGboZ+*2Z8VI6XaV&9Jp`ywk9ogeACN8@=y@y2E z9>uUf@gYghN$%+US^DX<*;jh*A`?bg9kF7!jAp;6pl`oe)xR!q+WgkE%y!iciYzxV zI)4E_{X^|~hThT@M@;&_{9xhE`yh9V-+li`y{3hjXAL93q{TCv1a@0{01Nsj*ylQ& zd6)DC-B(UOx2X+gj>MN9Wt(yrW=p*XdtXVy=MEZgw0m{II4G`5#J=BCH*xMq5L37i z>@;EqCQIlg!w>b23xmDudQdA3{mYrFuspb!a2gJy)&KrX>qFVrwIG2DjAoZpi3 z`T8a!=>P(VMYI?E#Thc0-x|Nci)fc8keZk`h**VwC%BN@A@4{m1m)wr6KpE%e5Ly# zw?hsiq^|{iY^fe?1)XT|750F8Dm6h|5IQ-uX>rh!DNbC4`!uPNqvlfq6~p{m!x)xl zMG1G5LV8Gl=yyecCk3oK*W#EhTQCp6Q^ao z%?Cc130?0J#) zXLs64ww^@?H2vtbzrs!LWR|dfy3oKQ+xB{yc&QNh(9VBs^iZ3_+kr7;c1JB?_7_z) z^l)NJxnBDR0WHv-4k`vLwc6;An@2|$hHJ>gja9)zYR8ZD1<~FX3#E23RY|=tq5W`X+ z{%6v~|0p3(v4F)&o>nc8Hc5gDHKovM-5+FCY{h^>&{yYVeCF^$m%81^w&1(KpXRp| z{GY2o_bTx-nOb1bp(4Rjg+Y1F{{Q3Vp-SWJr9XY^_KQw-?HGNDdPB^(oFk`WOZkG!CN zou3(0ZegL^)4@*%OyONDK{P`8^B{Ae1S76AY^j-Sh66x1=GeL@QHD5Vj&zFdMBoSp2I54{A|mu{RGCD&5gD4rmrK1T`cfu=F6B-5FB zPj+0fYf#ta^Co}dVTe07%WW%f%wA=;FNbsM9rj_9~ z_; zV8P{M^?*0wBWO8RNraeTo?#E_XG^MA+Kttq(3`|%_e%Uvqf;umZwj^Fk_~YDKOQG6 zaQD5v01%6gwDx8ye?h_W(o-+LbZMW!AS_}h9BYPMz#$a9;H0w8uZ`;=k7KyYNzZMuVFn*yzu&zQO1%alFnNBh8>5u0_{)mGL#OA-Q z+abNCngxu>w3B~?0)fQ_$afQyztnuOb_Vu><9<02=TbnyJ*z(!E6qb4MhfD1F`TPm z#?e0vu3m(`{69sVWl$Z>6YjA92lrq>4;F$ZxH|`j0KtO0I|N(Y-Q6{K2=4AK!9(ES z?hcptUv=-TU)AhZ?T6W#>e-%odbXQ4zcB707vHda^vh2*P_1UN1Dmy1EXxfH6&$u- zs3+Wk7~zjJt4_|prB)X{0@HJqz%m6gb|A8-GYaL2?selWT*EtpoD_BAduQ(d5L6a|uNfuV9(CfXDv|3rMWgi$;mHlr#h0Q{B34O%2h zl6X=+vPqr(2Zetlq>E-k-cWMoz>%|ddeNYTcYYyVVjBkCgN8_#DdB>+9PCQ_FIgAllX)#?Pr^FLy+8L zv5`Q+G`ieRE{`vN2jPq0!biiC{XkxgW!IRVrz z2OW4N1bP|4oH=uta6?Qw;kbQ-A9?Ey1`S>sMO%F`;s8G$o~(6lel9&#vM(;j?GJj; zheIdWu24MO?;EULq59&rA-Iu4s!sb=zh?^&gcHzu-I3ln-UN@m3nld<8| zl<@g&g8>1eFE9z^Jm6U&(bv$o1^tWs3)79g=&tB4uf*=oZJ1zSTnfb4y5k>v60Fvz z5ufH&T{JDcyU_ecSSFNc3ON!Orf>y^(gj}vd{PB12-YjBZEiavwoHVt#PkMf4SjcE zB&j~sx5+H)7nQKGHAQ{}vQlF9CuMa!6?JFJ9RMa4M;cUU?1UH_&)~YeM@>N!t8(-Y zK?RPXh))R-)0bYBdSs<}HBA%#U46M#^60(=>ErpA%)%WT^NfS?tHaD|@AIY@iR9;TC;*-(3Uq>h~&d*$dnT3|3$AUe?=9JnZfDb&64! zCYweuY;qlbl!tKFdVXjL<-XfTdcd@r1q#CWs6O*VJL(G5XwGl9IbK|lc`K4)1kli| z)0Bk2fDyn5?5j*5*f&JV0%7uC?qLvM5&Uq^BD{p{1u5DvC2GLvK3y&ZQoKUKZ;98t zfmlo>Rtj<@GK*X!yj3vL4D91>nw@)%(2383{@4r&BFjted(YmIsh6gAu1!Ew3!k2@ zt3`DSghgw|)vEGzIFk2tx-$}Sc1qTVc_y&82(+>@s!V@1z7!?7qtqwQVaKN_Yj+U0 z{@gYH6>U{ewsGCteEvZ?C>kKcCD}RtEVZnH?{qyzJF(18(Orh=qatG5ulVykVJ^-g z0pETw=Ltk)@(6+Lj2_@^`m~k>sYD5oZ`$|`GEE}U1zlE z#^o=G3H^#faZtD z_HtnS==y_JRE*JSYx}`ML}wg4!C7>9@F)r8IaZ`mMrj<3dR^|YZZrpnu}8UXS@x>! zF;QlSMB8GmuC;A9sU5+mD6ijQB*((PceYE0o2XM4vO>-ri51|o`+gbU+kU>_<^**h z?hwo+n>ai1t6A%kD>VVMhDT9^bpa9#`QbHji}8zj%&xIy)l1HM?O5@kVXCjB#}v#( zF~^tlp4q{F+mu-diIq2b!>kKNzh9h4T$o}cc-`9gfDHYq@Z{byr<*^w)f}DYf+ORZ zXXF^VSx#G!WaIrKz4JGA%4>E&2)Vz+4w z<#tJb3`LQaxvnQ6jII8RV5Lvg=2^?_Z%3-o?z28Cv!dXUq5i4QsGDWAT-t)^g`%5NwolR5JNooz1r#Gvby(r=G%^8X(mY5pxv=mC`yhHy_N| z%dewGo{`BmF9#NfOYtj&T3W<@KcF>F^`@jUwmrILFZy4s{)<^n-*!ZGc3M%%b$Xs= zL{Qj8+8ZGEP}HN|s&#(~7xF|K?2Z5tMU5CE z8(1&!BTmp2%JTY?A->buYu?6TCD?2$NO8*f5UcZB%mrxpasOm^Wfmg1nno~|#Vu6F zn$K|0V>==CEg;&Nw)Bw6Oua&2vCaXK^9@n!$Rl?*0Jq`wouZ3hiAM+#dA1YTNf?*U z6`g!#yhi&{wB2cz+GU&)piYu$P<-*`dH>rQ7i|p!eGG-qv6jL zHl(VB>p+w~@}gjFc=!`jaJKZiCnVoN`xzDM+xul8ve~4=W|8r=4-e~xuAszopSPFw z0+D3q1^PS-J)XQ-`>_0?_+sojy@@F~t7rYt8+>2*Nq_ln=d(N3!szY|;vC4Hz> z?yFIVUes8=I90r<+hj+%5~v$D<6B;5fIA>k8!)EN8WVy$cw>!`kvF0eihYuMTE?Jqe6`nlwJxY^4c z@V<0QpU5^qIMt$O&ISs1)M|zK$_yMUf;CsxJjRx!N$!KSn<6G4? zyZFeG>b5>ecu1*8Wf}#Q8Rh2$d$IJ}8ZQC%dMXh3R9!^sN*k}*6rQS6(S$(Svh%>K zRMl(;I@6o;S!66XYL5AX3JQGLq zT-immMwK%2!3K|C+(@>vZlp@sSZ2JTy1^Jq60_q{jH(W$+!do4A)M=*tbm(+7zJdm z*XI&dubWxgdN+047$c zlv9(mmj8I$CH8mQwHGiG+oUUxow3k4x$Qc3MYtCc4i{)#D38_9jC{);5>Lga*ng$wj-n~K}| z?lgbV&Lv*iN7j}0LKo5|^(L1b!!bMyql#;E5~mWZNW>g1z;G~x4$nNjSA8GGE+T16 znLt6^#W+!We16m&J^bl^qOOWfNTgq+MQCKLSHgX=r<1q2U;)>;p6RZ~Qii9CTY86Q zMn|(3*}{cOYoXVpY(n`{2tuQ90dngB|KXg82qaSl}_wRn{dzlIzF-Yv znx)YS1_#fmAi=Q|(Zmy;hv4Z-D&fGh%qAt$&d=ti@My8rnTp_jp7V(DgtKe=_jNDk z2iB-ys8ulZhxMm`2s2kH>^*J^75nlDnSUXbyflpm#*6HO-QHPNxynM9(p7@-Rz!@L zCc`1@v+4ZFrGh{NW{;jtyZ-k4blq9q_z?9lwdO&bF_*;sZd^#*H6C$!S#-DKqiWUV zLLrG%2}vs&q^H|R^P(2KUAmbD^#d!Y*X9@eT-FIupEV(h4N{1FAaFJeiV~YSg=;}B zMaJWJhjPPPizk|7WQ1Xm<;PX!P@C{M?$2}Ptb4zfRpGJ-q4 z!IK?{kT?%bzU7R8XKF`%asdC@^b+3VmFs#?Xu(bBd&PI|jMForVG|zhT=p0Ak#_%# zTy|?hXg5&u-{(6++cG}f%Wn7YLB(fXK!v#O^y#Iwh0D~*71A7zAWQuX?cvL>*Odv8 z=XjlyGYgY$i=v&U$Asq!m63dm$RE{es#nDvFM=$fO1t*=!xr}(Mc@+leC%O{;j$`R zSw|Vi164;4s*gNbmsQYW9LL!nK7}FqVfmr}Wx(+(C1NmlQgX(QQy$WHgi09@j26CD z(%jqmERS3@$oI1Qua|T#HY;oe$iB`&&T5Qr7aAvtN-eF*md`|Mw}L3@cojCdwe%Xw zH8MD$Tz!ddnI4pR8BaBD6m=Z+MEFuI4%H3{4a)za2@Uuntj$WLC$axis7Q2Q2H-qI zo}GOn`xw9Ht-Y8|C3$95L0;ErTT%EH4M>Pv?MU=muI_x`s9(;S}*y3Q!LN4|0VKSwZp{P+sv1Wy;tb`3|f+#X-5Q>Mq|$1Rq# z86Nj92M%R+Zwb&;{)@HHNhv$|uY8gtj3RSOy-aa416Eyin7KT!#l8Su>^tQD+lnl| zI52h?IQ*;>%UP@E(smms+!|fvdL0UmFt_gT!YX`eo7t!*mdC(Qr+W;TznH^zj^5To zev`XuF@ANw^tk#@h=T+Vq{nz*D3~zUQkKZGd8hv5X2JQH^|~Tn___=8^9D>tbktB! zq@Pe==ZhvO!%{`o0J$S^%1=LsGbah+x;`!hpAqyge~N8Ha1K0y8~z^B0LE!4GZ+@A z2(&jav`btjR^qrE1L==ZW$@;-N4@=g9e6W^D`oq6VcOEN4S|7t9CL59MFj zry?jKqK}no-YsCauh1HYtvll*J4cDzWkptm?xE9_ha`9h@B=q{8_$R`1TyM2dy-_@ zMH~Qqb%6|bM%Bzp-=ZTMfh&otb`o{Knxr*aqX4C|o0hfQUhs0Vvj%7_G>Wo8&CfRU z*p-UQ&?wcWJ&vTdmcmwBTtcho9`A#>LE{SQ@2Qokm7n}XR}HEjtzz8-=bY26HvSoV z=n4dT#9`~9jR3Zto9~uSg!|*$d%Qi~w5iV{Id35JCpo_f<^T-k!`~TysyF^Lhf<19 zFRw{>MOCgomDUy{BSMn|H-sqawi3hMY6MzyghzL33|mbEk;1P@{|j67$6!>sQ$G&F z(^aa>6|)?)Z6FZlNtDx}f8WJZdSRT1YR+W-9IC-66&WjTJQyQ|0k6*8HI;iL0(8o?^`o)<$(JR~L z^PoNXcar&5V2@i1uRO#pLv-3G{_1^q2CVvB$x%C(yf&5+X^LC|CQ8*-F`~`Jk^4&i zXskgA^-tqYY>yu#BQ~f$Zc#KLp9SN|VYLHP9zph+`pdiYgxnTqFHG zRTL#m0b+}#yv(UKhz#dj;AC5 znf7m<0Po`L{0^7?Ky4lj4r*rJXFS$v5OKsE)#flwhqQg@nZ_^oPuTYGw6d@X*94U6 z=VuoLl*t5CvM>cKsI4^^T4O436U7;c6l~W+sVLOQhOHcIE* zPrOPnQ@&_{XwF|6D6GErB8Hbn42d!WL(3XpKc0H^fY_^<&?{s8H#oEM@Y5*RMJyF& z-YhZbZqwRJ879O45uY{SG!{gF$@11(QX;-nl{W4tF!mopD9Ro`<=@AuFs8>hq2JIu zJMC26p$}!o{?19=g7AW)Q|Kusp7Lu*4K@*O?&I9gg06SdMZ~sh;z0wu`OXaBKiBiny@>Ew z_{RURwa#*S5@0;6^}xqmb#fAqYS#H==(=?Dv#7cj7~jnCx}Yn6g?`3ag6p=Lb@yad ziCx`g*X>!o`>p`wJ6&zf4!zictZ3aVN0VR7c~={@%jX}x8hpZ>lAr%`vZ?P<>Y17{ z+aD;21&J;(CkCgdbZt(>JSr+za@I<@D(jPW`!hWVdHt0^UV0!WOU!SxNJcvp@TOCZT!Ci(>kb`EwWXpi(G+8oBLJB*giCwbxq?TeYO2_?EfMZpS>AOn^<< z)yxu&0QO`iPQ9A0BDLL_(kw1c$Do_;P0PhUCfc0I?Zoaw)6`9YPLtV2qkNW^~bwKY>pRyc7?RJn1n>w!rhgM%c~dXBy)b zDfLLt=n`8--cXXM+ISa9xIHn@VyfCXD>_0bU7pbeJrAa5Us{y4hTOJDl$d@NfMvLs*D%$E@A{11i4gb7ct(s_S z3U%g!nz8+5u~uQ^?c+C1LpQ+Jv0PdBtHOU1OYGJun|KzaI>hV?0^3EX{5OgR>cTdP zWvqO5AyOUU7c;^aa3ETQzm$3-{%)s0EK5=qF3jm!?8l$OLn+~xdfd`?)dW@ur?D&+ zlwIP9$j0wTp|bwctP^JSUkGoGl1b50zcEMnfpGmVV*_BX-};B@b3+7-HO#j4rwq3D zYc9?CudGMjjy>`9>OSO0JDLjJFmplaw>C=j2EGvs{Wik-x_eg>R&N0MN^1uAjK=?G z^PJl)laP)XgVBMVYY~Q(<)JK-@19R@|GCaZv+^KpI7$b>tX9}j!^ncVez0Bp$|8>k z?l1@Lz}M9N_;~zhE#pw^lBoUPmrR8A?!`yj4(A)y<+}Knnuzk&*{cy*&wo-*Yft~Y z>&N1c{x;rmMW80^@?`5}`(OZPt-@E6Tqc?D{UOu2JbjlYq-f(}=SQv4t^|tGVZ4)0 zcxVkat>-^S_02344qZ%N5uT9A-v1CcGq`tt&=)MdQa+sqhiYm>1c$? zgT)g&%M%+>IIX!yB53FzT^jCe5yGa7!?PCm%VRgroN`(;U*cpxIvgu3Idt`FoOndy zFHywkM3qo-a8V#IBL2G2Op9`5SD4^9$)HO6!%QGa??OT9VuIAw@fBYw(>ZS@=p*$) zLV~D+WtTz=y~58O8+j1zeByaqyk-7o;dP2ZT49>%48HP}QjSv21hnAyt4iRvDaF1$ z0m)Mlj}}U6;Xe#iBtciso~Dct)5lwwq7t-T_Wf8$h$A`RnV1bub?n7;rgNrCGan={ z%zeg7%M%R{4Tvvl`Dd6XB4J!Ml{=L?w=D5PGF~xmm@YzJ!y8FJW^?#}Z*Ll&3*+{o zPS|;B{og(D0Ch6v;3eRBoZ-&H%Ny#Vj2UaBbb}Qk*QXC_0K3v-Dt6k>i{8Lj0OPAY zpMzKWPkk1U`xW(J5}X1~@gUdL5ahfy=gtBrOUrKOsD$5St%az5fv>a=0uz-spd~hV zAWstXB)DiOIYEmyFH0BObSHWh#xWCmAvRVm2qwYx zztxLV=ecBdDBKxtLxuj;QlKvrD(iguDs#X>bxl`bmPs7g4jvq$H;5w=Cj!4XAe=0>nW9iJXk(*Vng}(!Azr#Cy;n0^IEY#44*dL9zJVu8kPuVFBXBl)iTn4w z=)XGbARS$vzv9f8KXP1T=(a4-L*{%w{%G?ZBxAsUwm)qI;vrp-;dhL+&_df|N&Ld4 z8oHOnKxHhCfpCa0@E7p!^@R}#g;Qdf$pOD;>u+HyddAT)D&*4`_X0BB3(RqU3+Afb zpwVFyu2Yi%=;ya#Sk|0}bT`3@d3GIBU650@usI8~&i_gG-py@yy-&*~qK$7UkC(YR zjrbqUxDtkR)1RxWy%QoLqZP2S3-oI$#aGOF6qTa`JD2>#hYK4~X16>!>w@cxHG3^=QbE{pGS$on)QG@kn&oNx1p;2mb37q$b= zXQs_>Zr-N+(-qkhsV>9Q3q;B&s2E5ZNFE}ou@-;}!G&3$1`}dcex~%D#>Muet8|pC z%EhBtX{ja>-@=a~+&-oFa7W4K*H?+Qr?q=GxVwd%eA(i~D-J3CoiQ*9(bY>&C%Zqm z)xV+)AAnEkHx#O&o#87B!S#pWcK`k$bvV6jGZ5alhHHb0C7nj#1x$oBV|H^_Nx-$9 zdwd%TkN;eQjaMyCHO#erSQUf&dN@Dc$N&0#^_mUV<;iw07(SZJ@;=CVukf6NnfAXG zNg6IcH@TFUXZ`cm%%#;dE@cRTs3-yL(};z0 zKzA1`RH0)p;0XZl8F|_P6y2vO3gLvS3^zsi$p&OGc`~%*U!PJ371xmxw9;$%!jgRS z?-0?FThQ#g4PS|PC#6vqtf=_18H-v2&utO1|I8r=?9(%!9242o~*mYJb>ZEN5x&Y zu`-J5B^dznQ{MBXJ-aWpbF}T^aP6A^5)#jRDf=?pk?bXo$K-vQ=5SKCy36^nQ(Yp$ z2yZ<8_wc%tn2rkqiY(usl6<)PV>bGsVjCt$@OGm5uU>Z6i>r^1>zXIv`S{W+#5`GL z>)H6W-+poRUTA$d{^jQ8aPuf{cassn*?gZu#{#@QkFF$qW87K2M}R&zd}X;gj*&fb zox|k!2Aq`Rrr_`0Nzj#v2un-U3Gry@&a(O@!A`s}x^K=6trTgS%mG zcQ+4ut5fs@bJmK1^W(=uMYF~!7T_8#Qb>S;^(fx4o z7LcmxurkC|jIfkb*vWTa7k~SrRjQ)?S1T285L*{oB7aSJzFX44Kg?1WiRWQWiFivn zT#zJ|BIsEDicsN9uRc<{b#(J*9^iev5;N=_}KgzPjNnsabxy7zg4 jkPJe;+l~~Sp4n?D@G1lY1M~U{4|5zio_c&11N(mf$5V6I delta 79305 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Μ`b{VWrDq<`+RKa55VBug7 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 z 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%0DxNkJ69ZSa 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�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≪-oZ8A~= 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 w!dld~)MgbtlFIloFB0$D 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 WceY@vZ~Ni@y+5@UcY0GrLH-{-9s0fi diff --git a/build/cache/openxr.json.gz b/build/cache/openxr.json.gz index d53c1412772ec304b11738611c1fbf2c41f7a05d..34d4283b848a92bc6628bac87a23de675c6f45ad 100644 GIT binary patch literal 56929 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 D*CQth literal 53280 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 aUrlH??mXK2zhhWfG{V!Im*Kxqf(@53j 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

SK`m8$v6?LhXxH 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ˈ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

g&%vO&?;?BAxg?faqc33tZ48Q(j%asTpm4Wwbh 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 C; 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 z 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 zPTrpreview .NET Foundation and Contributors - Silk.NET July 2021 Update + Silk.NET August 2021 Update - - Add support for OpenAL Soft native libraries for ALContext - - Update to Vulkan 1.2.183 - - Update to latest OpenCL specifications - - Fix struct layout issues in DirectX and OpenXR bindings - - Fix OpenCL library name resolution on Linux - - Fix NU5127, NU5128, and NU1701 native package NuGet errors on .NET Framework - - Improve FileNotFoundExceptions when native library loading fails - - Improve GlobalMemory call chains by removing unnecessary usage of Span<T> + - Add code signing to all Silk.NET binaries + - Add support for platform-default calling conventions + - Update to latest OpenGL specifications + - Update to Vulkan 1.2.187 + - Update to OpenXR 1.0.18 + - Fix loading some OpenAL extensions OpenCL;OpenGL;OpenAL;OpenGLES;GLES;Vulkan;Assimp;DirectX;GLFW;SDL;Windowing;Input;Gamepad;Joystick;Keyboard;Mouse;SilkTouch;Source;Generator;C#;F#;.NET;DotNet;Mono;Vector;Math;Maths;Numerics;Game;Graphics;Compute;Audio;Sound;Engine;Silk;Silk.NET;Slim.NET;ElgarTK;GPU;Sharp;Science;Scientific;Visualization;Visual;Audiovisual;Windows;macOS;Linux;Android;Bindings;OSX;Wrapper;Native true $(MSBuildThisFileDirectory)/../output_packages https://github.com/dotnet/Silk.NET Git - 2.6.0 + 2.7.0 Silk.NET is a high-speed, advanced library, providing bindings to popular low-level APIs such as OpenGL, OpenCL, OpenAL, OpenXR, GLFW, SDL, Vulkan, Assimp, and DirectX. diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGL.Extensions.INTEL/IntelPerformanceQuery.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGL.Extensions.INTEL/IntelPerformanceQuery.gen.cs index cd421b5626..83868ba474 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGL.Extensions.INTEL/IntelPerformanceQuery.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGL.Extensions.INTEL/IntelPerformanceQuery.gen.cs @@ -48,868 +48,868 @@ public unsafe partial class IntelPerformanceQuery : NativeExtension public partial void GetNextPerfQueryId([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.Out)] out uint nextQueryId); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfQueryDataINTEL")] public unsafe partial void GetPerfQueryData([Flow(FlowDirection.In)] uint queryHandle, [Flow(FlowDirection.In)] uint flags, [Flow(FlowDirection.In)] uint dataSize, [Flow(FlowDirection.Out)] void* data, [Flow(FlowDirection.Out)] uint* bytesWritten); @@ -942,148 +942,148 @@ public unsafe partial class IntelPerformanceQuery : NativeExtension public partial void GetPerfQueryIdByName([Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint queryId); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); public unsafe uint CreatePerfQuery() { @@ -1111,6 +1111,1542 @@ public unsafe uint GetNextPerfQueryId() return ret; } + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + public unsafe uint GetPerfQueryIdByName([Flow(FlowDirection.Out)] byte* queryName) { // ReturnTypeOverloader @@ -1119,6 +2655,198 @@ public unsafe uint GetPerfQueryIdByName([Flow(FlowDirection.Out)] byte* queryNam return ret; } + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, out noInstances, out capsMask); + } + public IntelPerformanceQuery(INativeContext ctx) : base(ctx) { diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGL.Extensions.INTEL/IntelPerformanceQueryOverloads.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGL.Extensions.INTEL/IntelPerformanceQueryOverloads.gen.cs index bb367d0886..8fd9d5a0bf 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGL.Extensions.INTEL/IntelPerformanceQueryOverloads.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGL.Extensions.INTEL/IntelPerformanceQueryOverloads.gen.cs @@ -34,1708 +34,1726 @@ public static unsafe void GetNextPerfQueryId(this IntelPerformanceQuery thisApi, thisApi.GetNextPerfQueryId(queryId, out nextQueryId.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + { + // SpanOverloader + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + } + + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + } + + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // SpanOverloader + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + } + + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + { + // SpanOverloader + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } public static unsafe void GetPerfQueryData(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryHandle, [Flow(FlowDirection.In)] uint flags, [Flow(FlowDirection.In)] uint dataSize, [Flow(FlowDirection.Out)] void* data, [Flow(FlowDirection.Out)] Span bytesWritten) @@ -1780,280 +1798,286 @@ public static unsafe void GetPerfQueryIdByName(this IntelPerformanceQuery thisAp thisApi.GetPerfQueryIdByName(queryName, out queryId.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, out noInstances.GetPinnableReference(), capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), noInstances, capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, noInstances, capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, noInstances, out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); + } + + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + { + // SpanOverloader + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } } diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.INTEL/IntelPerformanceQuery.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.INTEL/IntelPerformanceQuery.gen.cs index b511bdab48..bbd025da0f 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.INTEL/IntelPerformanceQuery.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.INTEL/IntelPerformanceQuery.gen.cs @@ -48,868 +48,868 @@ public unsafe partial class IntelPerformanceQuery : NativeExtension public partial void GetNextPerfQueryId([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.Out)] out uint nextQueryId); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfQueryDataINTEL")] public unsafe partial void GetPerfQueryData([Flow(FlowDirection.In)] uint queryHandle, [Flow(FlowDirection.In)] uint flags, [Flow(FlowDirection.In)] uint dataSize, [Flow(FlowDirection.Out)] void* data, [Flow(FlowDirection.Out)] uint* bytesWritten); @@ -942,148 +942,148 @@ public unsafe partial class IntelPerformanceQuery : NativeExtension public partial void GetPerfQueryIdByName([Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint queryId); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); public unsafe uint CreatePerfQuery() { @@ -1111,6 +1111,1542 @@ public unsafe uint GetNextPerfQueryId() return ret; } + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + public unsafe uint GetPerfQueryIdByName([Flow(FlowDirection.Out)] byte* queryName) { // ReturnTypeOverloader @@ -1119,6 +2655,198 @@ public unsafe uint GetPerfQueryIdByName([Flow(FlowDirection.Out)] byte* queryNam return ret; } + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, out noInstances, out capsMask); + } + public IntelPerformanceQuery(INativeContext ctx) : base(ctx) { diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.INTEL/IntelPerformanceQueryOverloads.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.INTEL/IntelPerformanceQueryOverloads.gen.cs index 84dc1fae21..64afa6eae2 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.INTEL/IntelPerformanceQueryOverloads.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.INTEL/IntelPerformanceQueryOverloads.gen.cs @@ -34,1708 +34,1726 @@ public static unsafe void GetNextPerfQueryId(this IntelPerformanceQuery thisApi, thisApi.GetNextPerfQueryId(queryId, out nextQueryId.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + { + // SpanOverloader + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + } + + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + } + + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // SpanOverloader + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + } + + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + { + // SpanOverloader + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } public static unsafe void GetPerfQueryData(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryHandle, [Flow(FlowDirection.In)] uint flags, [Flow(FlowDirection.In)] uint dataSize, [Flow(FlowDirection.Out)] void* data, [Flow(FlowDirection.Out)] Span bytesWritten) @@ -1780,280 +1798,286 @@ public static unsafe void GetPerfQueryIdByName(this IntelPerformanceQuery thisAp thisApi.GetPerfQueryIdByName(queryName, out queryId.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, out noInstances.GetPinnableReference(), capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), noInstances, capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, noInstances, capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, noInstances, out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); + } + + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + { + // SpanOverloader + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } } diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.NV/NVTransformFeedback.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.NV/NVTransformFeedback.gen.cs index 138f657f60..cb97851b1f 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.NV/NVTransformFeedback.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.NV/NVTransformFeedback.gen.cs @@ -57,76 +57,76 @@ public unsafe partial class NVTransformFeedback : NativeExtension public partial void EndTransformFeedback(); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] out byte name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out byte name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Flow(FlowDirection.Out)] string name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out string name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] out byte name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out byte name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Flow(FlowDirection.Out)] string name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out string name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] out byte name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out byte name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Flow(FlowDirection.Out)] string name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out string name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] out byte name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out byte name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Flow(FlowDirection.Out)] string name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out string name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] out byte name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out byte name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Flow(FlowDirection.Out)] string name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out string name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] out byte name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out byte name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Flow(FlowDirection.Out)] string name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out string name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] out byte name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out byte name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Flow(FlowDirection.Out)] string name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out string name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name); + public unsafe partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] out byte name); + public partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out byte name); [NativeApi(EntryPoint = "glGetActiveVaryingNV")] - public partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Flow(FlowDirection.Out)] string name); + public partial void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out string name); [NativeApi(EntryPoint = "glGetTransformFeedbackVaryingNV")] public unsafe partial void GetTransformFeedbackVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] int* location); @@ -167,6 +167,102 @@ public unsafe partial class NVTransformFeedback : NativeExtension [NativeApi(EntryPoint = "glTransformFeedbackVaryingsNV")] public partial void TransformFeedbackVaryings([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(FlowDirection.In)] in int locations, [Flow(FlowDirection.In)] NV bufferMode); + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, length, size, type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, length, size, type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, length, size, out type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, length, size, out type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, length, out size, type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, length, out size, type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, length, out size, out type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, length, out size, out type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, out length, size, type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, out length, size, type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, out length, size, out type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, out length, size, out type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, out length, out size, type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, out length, out size, type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, out length, out size, out type, out name.GetPinnableReference()); + } + + public unsafe void GetActiveVarying([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Count = 1), Flow(FlowDirection.Out)] out uint size, [Count(Count = 1), Flow(FlowDirection.Out)] out NV type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // ImplicitCountSpanOverloader + GetActiveVarying(program, index, (uint) name.Length, out length, out size, out type, out name.GetPinnableReference()); + } + public unsafe void TransformFeedbackStreamAttrib([Flow(FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(FlowDirection.In)] int* attribs, [Count(Parameter = "nbuffers"), Flow(FlowDirection.In)] ReadOnlySpan bufstreams, [Flow(FlowDirection.In)] NV bufferMode) { // ImplicitCountSpanOverloader diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.NV/NVTransformFeedbackOverloads.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.NV/NVTransformFeedbackOverloads.gen.cs index 01a8429266..76f051bc4e 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.NV/NVTransformFeedbackOverloads.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGL.Legacy.Extensions.NV/NVTransformFeedbackOverloads.gen.cs @@ -22,136 +22,142 @@ public static unsafe void ActiveVarying(this NVTransformFeedback thisApi, [Flow( thisApi.ActiveVarying(program, in name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] Span name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, length, size, type, out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) + { + // SpanOverloader + thisApi.GetActiveVarying(program, index, bufSize, length, size, type, out name.GetPinnableReference()); + } + + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, length, size, out type.GetPinnableReference(), name); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] Span name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, length, size, out type.GetPinnableReference(), out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Flow(FlowDirection.Out)] string name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader - thisApi.GetActiveVarying(program, index, bufSize, length, size, out type.GetPinnableReference(), name); + thisApi.GetActiveVarying(program, index, bufSize, length, size, out type.GetPinnableReference(), out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, length, out size.GetPinnableReference(), type, name); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] Span name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, length, out size.GetPinnableReference(), type, out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Flow(FlowDirection.Out)] string name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader - thisApi.GetActiveVarying(program, index, bufSize, length, out size.GetPinnableReference(), type, name); + thisApi.GetActiveVarying(program, index, bufSize, length, out size.GetPinnableReference(), type, out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, length, out size.GetPinnableReference(), out type.GetPinnableReference(), name); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] Span name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, length, out size.GetPinnableReference(), out type.GetPinnableReference(), out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Flow(FlowDirection.Out)] string name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader - thisApi.GetActiveVarying(program, index, bufSize, length, out size.GetPinnableReference(), out type.GetPinnableReference(), name); + thisApi.GetActiveVarying(program, index, bufSize, length, out size.GetPinnableReference(), out type.GetPinnableReference(), out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), size, type, name); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] Span name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), size, type, out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Flow(FlowDirection.Out)] string name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader - thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), size, type, name); + thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), size, type, out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), size, out type.GetPinnableReference(), name); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] Span name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), size, out type.GetPinnableReference(), out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Flow(FlowDirection.Out)] string name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] uint* size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader - thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), size, out type.GetPinnableReference(), name); + thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), size, out type.GetPinnableReference(), out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), out size.GetPinnableReference(), type, name); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] Span name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), out size.GetPinnableReference(), type, out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Flow(FlowDirection.Out)] string name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] NV* type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader - thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), out size.GetPinnableReference(), type, name); + thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), out size.GetPinnableReference(), type, out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] byte* name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), out size.GetPinnableReference(), out type.GetPinnableReference(), name); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Computed = "program, index, bufSize"), Flow(FlowDirection.Out)] Span name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), out size.GetPinnableReference(), out type.GetPinnableReference(), out name.GetPinnableReference()); } - public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Flow(FlowDirection.Out)] string name) + public static unsafe void GetActiveVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Count = 1), Flow(FlowDirection.Out)] Span size, [Count(Count = 1), Flow(FlowDirection.Out)] Span type, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span name) { // SpanOverloader - thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), out size.GetPinnableReference(), out type.GetPinnableReference(), name); + thisApi.GetActiveVarying(program, index, bufSize, out length.GetPinnableReference(), out size.GetPinnableReference(), out type.GetPinnableReference(), out name.GetPinnableReference()); } public static unsafe void GetTransformFeedbackVarying(this NVTransformFeedback thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] uint index, [Count(Count = 1), Flow(FlowDirection.Out)] Span location) diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.ANGLE/AngleTranslatedShaderSource.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.ANGLE/AngleTranslatedShaderSource.gen.cs index 9820fb5a3f..2db840ac81 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.ANGLE/AngleTranslatedShaderSource.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.ANGLE/AngleTranslatedShaderSource.gen.cs @@ -21,22 +21,46 @@ public unsafe partial class AngleTranslatedShaderSource : NativeExtension { public const string ExtensionName = "ANGLE_translated_shader_source"; [NativeApi(EntryPoint = "glGetTranslatedShaderSourceANGLE")] - public unsafe partial void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Flow(FlowDirection.Out)] byte* source); + public unsafe partial void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* source); [NativeApi(EntryPoint = "glGetTranslatedShaderSourceANGLE")] - public unsafe partial void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Flow(FlowDirection.Out)] out byte source); + public unsafe partial void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out byte source); [NativeApi(EntryPoint = "glGetTranslatedShaderSourceANGLE")] - public unsafe partial void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Flow(FlowDirection.Out)] string source); + public unsafe partial void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out string source); [NativeApi(EntryPoint = "glGetTranslatedShaderSourceANGLE")] - public unsafe partial void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Flow(FlowDirection.Out)] byte* source); + public unsafe partial void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* source); [NativeApi(EntryPoint = "glGetTranslatedShaderSourceANGLE")] - public partial void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Flow(FlowDirection.Out)] out byte source); + public partial void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out byte source); [NativeApi(EntryPoint = "glGetTranslatedShaderSourceANGLE")] - public partial void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Flow(FlowDirection.Out)] string source); + public partial void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out string source); + + public unsafe void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span source) + { + // ImplicitCountSpanOverloader + GetTranslatedShaderSource(shader, (uint) source.Length, length, out source.GetPinnableReference()); + } + + public unsafe void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span source) + { + // ImplicitCountSpanOverloader + GetTranslatedShaderSource(shader, (uint) source.Length, length, out source.GetPinnableReference()); + } + + public unsafe void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span source) + { + // ImplicitCountSpanOverloader + GetTranslatedShaderSource(shader, (uint) source.Length, out length, out source.GetPinnableReference()); + } + + public unsafe void GetTranslatedShaderSource([Flow(FlowDirection.In)] uint shader, [Count(Count = 1), Flow(FlowDirection.Out)] out uint length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span source) + { + // ImplicitCountSpanOverloader + GetTranslatedShaderSource(shader, (uint) source.Length, out length, out source.GetPinnableReference()); + } public AngleTranslatedShaderSource(INativeContext ctx) : base(ctx) diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.ANGLE/AngleTranslatedShaderSourceOverloads.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.ANGLE/AngleTranslatedShaderSourceOverloads.gen.cs index 70a61d7d4c..6768df0670 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.ANGLE/AngleTranslatedShaderSourceOverloads.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.ANGLE/AngleTranslatedShaderSourceOverloads.gen.cs @@ -16,28 +16,34 @@ namespace Silk.NET.OpenGLES.Extensions.ANGLE { public static class AngleTranslatedShaderSourceOverloads { - public static unsafe void GetTranslatedShaderSource(this AngleTranslatedShaderSource thisApi, [Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Flow(FlowDirection.Out)] Span source) + public static unsafe void GetTranslatedShaderSource(this AngleTranslatedShaderSource thisApi, [Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span source) { // SpanOverloader thisApi.GetTranslatedShaderSource(shader, bufSize, length, out source.GetPinnableReference()); } - public static unsafe void GetTranslatedShaderSource(this AngleTranslatedShaderSource thisApi, [Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Flow(FlowDirection.Out)] byte* source) + public static unsafe void GetTranslatedShaderSource(this AngleTranslatedShaderSource thisApi, [Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] uint* length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span source) + { + // SpanOverloader + thisApi.GetTranslatedShaderSource(shader, bufSize, length, out source.GetPinnableReference()); + } + + public static unsafe void GetTranslatedShaderSource(this AngleTranslatedShaderSource thisApi, [Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] byte* source) { // SpanOverloader thisApi.GetTranslatedShaderSource(shader, bufSize, out length.GetPinnableReference(), source); } - public static unsafe void GetTranslatedShaderSource(this AngleTranslatedShaderSource thisApi, [Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Flow(FlowDirection.Out)] Span source) + public static unsafe void GetTranslatedShaderSource(this AngleTranslatedShaderSource thisApi, [Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span source) { // SpanOverloader thisApi.GetTranslatedShaderSource(shader, bufSize, out length.GetPinnableReference(), out source.GetPinnableReference()); } - public static unsafe void GetTranslatedShaderSource(this AngleTranslatedShaderSource thisApi, [Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Flow(FlowDirection.Out)] string source) + public static unsafe void GetTranslatedShaderSource(this AngleTranslatedShaderSource thisApi, [Flow(FlowDirection.In)] uint shader, [Flow(FlowDirection.In)] uint bufSize, [Count(Count = 1), Flow(FlowDirection.Out)] Span length, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span source) { // SpanOverloader - thisApi.GetTranslatedShaderSource(shader, bufSize, out length.GetPinnableReference(), source); + thisApi.GetTranslatedShaderSource(shader, bufSize, out length.GetPinnableReference(), out source.GetPinnableReference()); } } diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.INTEL/IntelPerformanceQuery.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.INTEL/IntelPerformanceQuery.gen.cs index f326e99f51..16fd522ac5 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.INTEL/IntelPerformanceQuery.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.INTEL/IntelPerformanceQuery.gen.cs @@ -48,868 +48,868 @@ public unsafe partial class IntelPerformanceQuery : NativeExtension public partial void GetNextPerfQueryId([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.Out)] out uint nextQueryId); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out byte counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out byte counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); + public unsafe partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfCounterInfoINTEL")] - public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); + public partial void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] out string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] out string counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue); [NativeApi(EntryPoint = "glGetPerfQueryDataINTEL")] public unsafe partial void GetPerfQueryData([Flow(FlowDirection.In)] uint queryHandle, [Flow(FlowDirection.In)] uint flags, [Flow(FlowDirection.In)] uint dataSize, [Flow(FlowDirection.Out)] void* data, [Flow(FlowDirection.Out)] uint* bytesWritten); @@ -942,148 +942,148 @@ public unsafe partial class IntelPerformanceQuery : NativeExtension public partial void GetPerfQueryIdByName([Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint queryId); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out byte queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); + public unsafe partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask); [NativeApi(EntryPoint = "glGetPerfQueryInfoINTEL")] - public partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); + public partial void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] out string queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask); public unsafe uint CreatePerfQuery() { @@ -1111,6 +1111,1542 @@ public unsafe uint GetNextPerfQueryId() return ret; } + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, rawCounterMaxValue); + } + + public unsafe void GetPerfCounterInfo([Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] out uint counterOffset, [Flow(FlowDirection.Out)] out uint counterDataSize, [Flow(FlowDirection.Out)] out uint counterTypeEnum, [Flow(FlowDirection.Out)] out uint counterDataTypeEnum, [Flow(FlowDirection.Out)] out ulong rawCounterMaxValue) + { + // ImplicitCountSpanOverloader + GetPerfCounterInfo(queryId, counterId, (uint) counterName.Length, out counterName.GetPinnableReference(), (uint) counterDesc.Length, out counterDesc.GetPinnableReference(), out counterOffset, out counterDataSize, out counterTypeEnum, out counterDataTypeEnum, out rawCounterMaxValue); + } + public unsafe uint GetPerfQueryIdByName([Flow(FlowDirection.Out)] byte* queryName) { // ReturnTypeOverloader @@ -1119,6 +2655,198 @@ public unsafe uint GetPerfQueryIdByName([Flow(FlowDirection.Out)] byte* queryNam return ret; } + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), dataSize, out noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, noCounters, out noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, noInstances, out capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, out noInstances, capsMask); + } + + public unsafe void GetPerfQueryInfo([Flow(FlowDirection.In)] uint queryId, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] out uint dataSize, [Flow(FlowDirection.Out)] out uint noCounters, [Flow(FlowDirection.Out)] out uint noInstances, [Flow(FlowDirection.Out)] out uint capsMask) + { + // ImplicitCountSpanOverloader + GetPerfQueryInfo(queryId, (uint) queryName.Length, out queryName.GetPinnableReference(), out dataSize, out noCounters, out noInstances, out capsMask); + } + public IntelPerformanceQuery(INativeContext ctx) : base(ctx) { diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.INTEL/IntelPerformanceQueryOverloads.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.INTEL/IntelPerformanceQueryOverloads.gen.cs index b1a1895e18..9e18141f88 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.INTEL/IntelPerformanceQueryOverloads.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.INTEL/IntelPerformanceQueryOverloads.gen.cs @@ -34,1708 +34,1726 @@ public static unsafe void GetNextPerfQueryId(this IntelPerformanceQuery thisApi, thisApi.GetNextPerfQueryId(queryId, out nextQueryId.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] byte* counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + { + // SpanOverloader + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + } + + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] byte* counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] uint* counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), counterOffset, out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] uint* counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), counterDataSize, out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] uint* counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), counterTypeEnum, out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, rawCounterMaxValue); } - public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Flow(FlowDirection.Out)] string counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Flow(FlowDirection.Out)] string counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] uint* counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) { // SpanOverloader - thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), counterDataTypeEnum, out rawCounterMaxValue.GetPinnableReference()); + } + + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] ulong* rawCounterMaxValue) + { + // SpanOverloader + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), rawCounterMaxValue); + } + + public static unsafe void GetPerfCounterInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint counterId, [Flow(FlowDirection.In)] uint counterNameLength, [Count(Parameter = "counterNameLength"), Flow(FlowDirection.Out)] Span counterName, [Flow(FlowDirection.In)] uint counterDescLength, [Count(Parameter = "counterDescLength"), Flow(FlowDirection.Out)] Span counterDesc, [Flow(FlowDirection.Out)] Span counterOffset, [Flow(FlowDirection.Out)] Span counterDataSize, [Flow(FlowDirection.Out)] Span counterTypeEnum, [Flow(FlowDirection.Out)] Span counterDataTypeEnum, [Flow(FlowDirection.Out)] Span rawCounterMaxValue) + { + // SpanOverloader + thisApi.GetPerfCounterInfo(queryId, counterId, counterNameLength, out counterName.GetPinnableReference(), counterDescLength, out counterDesc.GetPinnableReference(), out counterOffset.GetPinnableReference(), out counterDataSize.GetPinnableReference(), out counterTypeEnum.GetPinnableReference(), out counterDataTypeEnum.GetPinnableReference(), out rawCounterMaxValue.GetPinnableReference()); } public static unsafe void GetPerfQueryData(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryHandle, [Flow(FlowDirection.In)] uint flags, [Flow(FlowDirection.In)] uint dataSize, [Flow(FlowDirection.Out)] void* data, [Flow(FlowDirection.Out)] Span bytesWritten) @@ -1780,280 +1798,286 @@ public static unsafe void GetPerfQueryIdByName(this IntelPerformanceQuery thisAp thisApi.GetPerfQueryIdByName(queryName, out queryId.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] byte* queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, out noInstances.GetPinnableReference(), capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), noInstances, capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] uint* dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, noInstances, capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), dataSize, out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, noInstances, out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] uint* noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), noCounters, out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, capsMask); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] uint* noInstances, [Flow(FlowDirection.Out)] Span capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), noInstances, out capsMask.GetPinnableReference()); } - public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Flow(FlowDirection.Out)] string queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] uint* capsMask) { // SpanOverloader - thisApi.GetPerfQueryInfo(queryId, queryNameLength, queryName, out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), capsMask); + } + + public static unsafe void GetPerfQueryInfo(this IntelPerformanceQuery thisApi, [Flow(FlowDirection.In)] uint queryId, [Flow(FlowDirection.In)] uint queryNameLength, [Count(Parameter = "queryNameLength"), Flow(FlowDirection.Out)] Span queryName, [Flow(FlowDirection.Out)] Span dataSize, [Flow(FlowDirection.Out)] Span noCounters, [Flow(FlowDirection.Out)] Span noInstances, [Flow(FlowDirection.Out)] Span capsMask) + { + // SpanOverloader + thisApi.GetPerfQueryInfo(queryId, queryNameLength, out queryName.GetPinnableReference(), out dataSize.GetPinnableReference(), out noCounters.GetPinnableReference(), out noInstances.GetPinnableReference(), out capsMask.GetPinnableReference()); } } diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.QCOM/QComExtendedGet2.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.QCOM/QComExtendedGet2.gen.cs index 560a2bdac6..83330a0c97 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.QCOM/QComExtendedGet2.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.QCOM/QComExtendedGet2.gen.cs @@ -45,40 +45,40 @@ public unsafe partial class QComExtendedGet2 : NativeExtension public partial void ExtGetProgram([Count(Parameter = "maxPrograms"), Flow(FlowDirection.Out)] out Program programs, [Flow(FlowDirection.In)] int maxPrograms, [Count(Count = 1), Flow(FlowDirection.Out)] out int numPrograms); [NativeApi(EntryPoint = "glExtGetProgramBinarySourceQCOM")] - public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Flow(FlowDirection.Out)] byte* source, [Flow(FlowDirection.Out)] int* length); + public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] byte* source, [Flow(FlowDirection.Out)] int* length); [NativeApi(EntryPoint = "glExtGetProgramBinarySourceQCOM")] - public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Flow(FlowDirection.Out)] byte* source, [Flow(FlowDirection.Out)] out int length); + public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] byte* source, [Flow(FlowDirection.Out)] out int length); [NativeApi(EntryPoint = "glExtGetProgramBinarySourceQCOM")] - public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Flow(FlowDirection.Out)] out byte source, [Flow(FlowDirection.Out)] int* length); + public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] out byte source, [Flow(FlowDirection.Out)] int* length); [NativeApi(EntryPoint = "glExtGetProgramBinarySourceQCOM")] - public partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Flow(FlowDirection.Out)] out byte source, [Flow(FlowDirection.Out)] out int length); + public partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] out byte source, [Flow(FlowDirection.Out)] out int length); [NativeApi(EntryPoint = "glExtGetProgramBinarySourceQCOM")] - public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Flow(FlowDirection.Out)] string source, [Flow(FlowDirection.Out)] int* length); + public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] out string source, [Flow(FlowDirection.Out)] int* length); [NativeApi(EntryPoint = "glExtGetProgramBinarySourceQCOM")] - public partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Flow(FlowDirection.Out)] string source, [Flow(FlowDirection.Out)] out int length); + public partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] out string source, [Flow(FlowDirection.Out)] out int length); [NativeApi(EntryPoint = "glExtGetProgramBinarySourceQCOM")] - public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.Out)] byte* source, [Flow(FlowDirection.Out)] int* length); + public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] byte* source, [Flow(FlowDirection.Out)] int* length); [NativeApi(EntryPoint = "glExtGetProgramBinarySourceQCOM")] - public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.Out)] byte* source, [Flow(FlowDirection.Out)] out int length); + public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] byte* source, [Flow(FlowDirection.Out)] out int length); [NativeApi(EntryPoint = "glExtGetProgramBinarySourceQCOM")] - public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.Out)] out byte source, [Flow(FlowDirection.Out)] int* length); + public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] out byte source, [Flow(FlowDirection.Out)] int* length); [NativeApi(EntryPoint = "glExtGetProgramBinarySourceQCOM")] - public partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.Out)] out byte source, [Flow(FlowDirection.Out)] out int length); + public partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] out byte source, [Flow(FlowDirection.Out)] out int length); [NativeApi(EntryPoint = "glExtGetProgramBinarySourceQCOM")] - public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.Out)] string source, [Flow(FlowDirection.Out)] int* length); + public unsafe partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] out string source, [Flow(FlowDirection.Out)] int* length); [NativeApi(EntryPoint = "glExtGetProgramBinarySourceQCOM")] - public partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.Out)] string source, [Flow(FlowDirection.Out)] out int length); + public partial void ExtGetProgramBinarySource([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] out string source, [Flow(FlowDirection.Out)] out int length); [NativeApi(EntryPoint = "glExtGetShadersQCOM")] public unsafe partial void ExtGetShaders([Count(Parameter = "maxShaders"), Flow(FlowDirection.Out)] uint* shaders, [Flow(FlowDirection.In)] int maxShaders, [Count(Count = 1), Flow(FlowDirection.Out)] int* numShaders); diff --git a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.QCOM/QComExtendedGet2Overloads.gen.cs b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.QCOM/QComExtendedGet2Overloads.gen.cs index 916c9a75e7..adad715f8f 100644 --- a/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.QCOM/QComExtendedGet2Overloads.gen.cs +++ b/src/OpenGL/Extensions/Silk.NET.OpenGLES.Extensions.QCOM/QComExtendedGet2Overloads.gen.cs @@ -52,52 +52,64 @@ public static unsafe void ExtGetProgram(this QComExtendedGet2 thisApi, [Count(Pa thisApi.ExtGetProgram(out programs.GetPinnableReference(), maxPrograms, out numPrograms.GetPinnableReference()); } - public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Flow(FlowDirection.Out)] byte* source, [Flow(FlowDirection.Out)] Span length) + public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] byte* source, [Flow(FlowDirection.Out)] Span length) { // SpanOverloader thisApi.ExtGetProgramBinarySource(program, shadertype, source, out length.GetPinnableReference()); } - public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Flow(FlowDirection.Out)] Span source, [Flow(FlowDirection.Out)] int* length) + public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] Span source, [Flow(FlowDirection.Out)] int* length) { // SpanOverloader thisApi.ExtGetProgramBinarySource(program, shadertype, out source.GetPinnableReference(), length); } - public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Flow(FlowDirection.Out)] Span source, [Flow(FlowDirection.Out)] Span length) + public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] Span source, [Flow(FlowDirection.Out)] Span length) { // SpanOverloader thisApi.ExtGetProgramBinarySource(program, shadertype, out source.GetPinnableReference(), out length.GetPinnableReference()); } - public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Flow(FlowDirection.Out)] string source, [Flow(FlowDirection.Out)] Span length) + public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] Span source, [Flow(FlowDirection.Out)] int* length) { // SpanOverloader - thisApi.ExtGetProgramBinarySource(program, shadertype, source, out length.GetPinnableReference()); + thisApi.ExtGetProgramBinarySource(program, shadertype, out source.GetPinnableReference(), length); + } + + public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] QCOM shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] Span source, [Flow(FlowDirection.Out)] Span length) + { + // SpanOverloader + thisApi.ExtGetProgramBinarySource(program, shadertype, out source.GetPinnableReference(), out length.GetPinnableReference()); } - public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.Out)] byte* source, [Flow(FlowDirection.Out)] Span length) + public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] byte* source, [Flow(FlowDirection.Out)] Span length) { // SpanOverloader thisApi.ExtGetProgramBinarySource(program, shadertype, source, out length.GetPinnableReference()); } - public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.Out)] Span source, [Flow(FlowDirection.Out)] int* length) + public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] Span source, [Flow(FlowDirection.Out)] int* length) { // SpanOverloader thisApi.ExtGetProgramBinarySource(program, shadertype, out source.GetPinnableReference(), length); } - public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.Out)] Span source, [Flow(FlowDirection.Out)] Span length) + public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] Span source, [Flow(FlowDirection.Out)] Span length) { // SpanOverloader thisApi.ExtGetProgramBinarySource(program, shadertype, out source.GetPinnableReference(), out length.GetPinnableReference()); } - public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.Out)] string source, [Flow(FlowDirection.Out)] Span length) + public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] Span source, [Flow(FlowDirection.Out)] int* length) { // SpanOverloader - thisApi.ExtGetProgramBinarySource(program, shadertype, source, out length.GetPinnableReference()); + thisApi.ExtGetProgramBinarySource(program, shadertype, out source.GetPinnableReference(), length); + } + + public static unsafe void ExtGetProgramBinarySource(this QComExtendedGet2 thisApi, [Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] ShaderType shadertype, [Count(Parameter = "length"), Flow(FlowDirection.Out)] Span source, [Flow(FlowDirection.Out)] Span length) + { + // SpanOverloader + thisApi.ExtGetProgramBinarySource(program, shadertype, out source.GetPinnableReference(), out length.GetPinnableReference()); } public static unsafe void ExtGetShaders(this QComExtendedGet2 thisApi, [Count(Parameter = "maxShaders"), Flow(FlowDirection.Out)] uint* shaders, [Flow(FlowDirection.In)] int maxShaders, [Count(Count = 1), Flow(FlowDirection.Out)] Span numShaders) diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.FB/FBFoveation.gen.cs b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.FB/FBFoveation.gen.cs new file mode 100644 index 0000000000..ace9866772 --- /dev/null +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.FB/FBFoveation.gen.cs @@ -0,0 +1,49 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; +using Silk.NET.OpenXR; +using Extension = Silk.NET.Core.Attributes.ExtensionAttribute; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR.Extensions.FB +{ + [Extension("XR_FB_foveation")] + public unsafe partial class FBFoveation : NativeExtension + { + public const string ExtensionName = "XR_FB_foveation"; + ///

To be documented. + [NativeApi(EntryPoint = "xrCreateFoveationProfileFB")] + public unsafe partial Result CreateFoveationProfileFB([Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] FoveationProfileCreateInfoFB* createInfo, [Count(Count = 0)] FoveationProfileFB* profile); + + /// To be documented. + [NativeApi(EntryPoint = "xrCreateFoveationProfileFB")] + public unsafe partial Result CreateFoveationProfileFB([Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] FoveationProfileCreateInfoFB* createInfo, [Count(Count = 0)] ref FoveationProfileFB profile); + + /// To be documented. + [NativeApi(EntryPoint = "xrCreateFoveationProfileFB")] + public unsafe partial Result CreateFoveationProfileFB([Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] in FoveationProfileCreateInfoFB createInfo, [Count(Count = 0)] FoveationProfileFB* profile); + + /// To be documented. + [NativeApi(EntryPoint = "xrCreateFoveationProfileFB")] + public partial Result CreateFoveationProfileFB([Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] in FoveationProfileCreateInfoFB createInfo, [Count(Count = 0)] ref FoveationProfileFB profile); + + /// To be documented. + [NativeApi(EntryPoint = "xrDestroyFoveationProfileFB")] + public partial Result DestroyFoveationProfileFB([Count(Count = 0)] FoveationProfileFB profile); + + public FBFoveation(INativeContext ctx) + : base(ctx) + { + } + } +} + diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.FB/FBFoveationOverloads.gen.cs b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.FB/FBFoveationOverloads.gen.cs new file mode 100644 index 0000000000..b670d15ebf --- /dev/null +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.FB/FBFoveationOverloads.gen.cs @@ -0,0 +1,42 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR.Extensions.FB +{ + public static class FBFoveationOverloads + { + /// To be documented. + public static unsafe Result CreateFoveationProfileFB(this FBFoveation thisApi, [Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] FoveationProfileCreateInfoFB* createInfo, [Count(Count = 0)] Span profile) + { + // SpanOverloader + return thisApi.CreateFoveationProfileFB(session, createInfo, ref profile.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result CreateFoveationProfileFB(this FBFoveation thisApi, [Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] ReadOnlySpan createInfo, [Count(Count = 0)] FoveationProfileFB* profile) + { + // SpanOverloader + return thisApi.CreateFoveationProfileFB(session, in createInfo.GetPinnableReference(), profile); + } + + /// To be documented. + public static unsafe Result CreateFoveationProfileFB(this FBFoveation thisApi, [Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] ReadOnlySpan createInfo, [Count(Count = 0)] Span profile) + { + // SpanOverloader + return thisApi.CreateFoveationProfileFB(session, in createInfo.GetPinnableReference(), ref profile.GetPinnableReference()); + } + + } +} + diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.LIV/Silk.NET.OpenXR.Extensions.LIV.csproj b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.LIV/Silk.NET.OpenXR.Extensions.LIV.csproj new file mode 100644 index 0000000000..caa36148a5 --- /dev/null +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.LIV/Silk.NET.OpenXR.Extensions.LIV.csproj @@ -0,0 +1,14 @@ + + + + netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0 + true + preview + + + + + + + + diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistence.gen.cs b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistence.gen.cs new file mode 100644 index 0000000000..f45583f114 --- /dev/null +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistence.gen.cs @@ -0,0 +1,107 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; +using Silk.NET.OpenXR; +using Extension = Silk.NET.Core.Attributes.ExtensionAttribute; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR.Extensions.MSFT +{ + [Extension("XR_MSFT_spatial_anchor_persistence")] + public unsafe partial class MsftSpatialAnchorPersistence : NativeExtension + { + public const string ExtensionName = "XR_MSFT_spatial_anchor_persistence"; + /// To be documented. + [NativeApi(EntryPoint = "xrClearSpatialAnchorStoreMSFT")] + public partial Result ClearSpatialAnchorStoreMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore); + + /// To be documented. + [NativeApi(EntryPoint = "xrCreateSpatialAnchorFromPersistedNameMSFT")] + public unsafe partial Result CreateSpatialAnchorFromPersistedNameMsft([Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] SpatialAnchorFromPersistedAnchorCreateInfoMSFT* spatialAnchorCreateInfo, [Count(Count = 0)] SpatialAnchorMSFT* spatialAnchor); + + /// To be documented. + [NativeApi(EntryPoint = "xrCreateSpatialAnchorFromPersistedNameMSFT")] + public unsafe partial Result CreateSpatialAnchorFromPersistedNameMsft([Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] SpatialAnchorFromPersistedAnchorCreateInfoMSFT* spatialAnchorCreateInfo, [Count(Count = 0)] ref SpatialAnchorMSFT spatialAnchor); + + /// To be documented. + [NativeApi(EntryPoint = "xrCreateSpatialAnchorFromPersistedNameMSFT")] + public unsafe partial Result CreateSpatialAnchorFromPersistedNameMsft([Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] in SpatialAnchorFromPersistedAnchorCreateInfoMSFT spatialAnchorCreateInfo, [Count(Count = 0)] SpatialAnchorMSFT* spatialAnchor); + + /// To be documented. + [NativeApi(EntryPoint = "xrCreateSpatialAnchorFromPersistedNameMSFT")] + public partial Result CreateSpatialAnchorFromPersistedNameMsft([Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] in SpatialAnchorFromPersistedAnchorCreateInfoMSFT spatialAnchorCreateInfo, [Count(Count = 0)] ref SpatialAnchorMSFT spatialAnchor); + + /// To be documented. + [NativeApi(EntryPoint = "xrCreateSpatialAnchorStoreConnectionMSFT")] + public unsafe partial Result CreateSpatialAnchorStoreConnectionMsft([Count(Count = 0)] Session session, [Count(Count = 0)] SpatialAnchorStoreConnectionMSFT* spatialAnchorStore); + + /// To be documented. + [NativeApi(EntryPoint = "xrCreateSpatialAnchorStoreConnectionMSFT")] + public partial Result CreateSpatialAnchorStoreConnectionMsft([Count(Count = 0)] Session session, [Count(Count = 0)] ref SpatialAnchorStoreConnectionMSFT spatialAnchorStore); + + /// To be documented. + [NativeApi(EntryPoint = "xrDestroySpatialAnchorStoreConnectionMSFT")] + public partial Result DestroySpatialAnchorStoreConnectionMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore); + + /// To be documented. + [NativeApi(EntryPoint = "xrEnumeratePersistedSpatialAnchorNamesMSFT")] + public unsafe partial Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] uint* spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] SpatialAnchorPersistenceNameMSFT* persistedAnchorNames); + + /// To be documented. + [NativeApi(EntryPoint = "xrEnumeratePersistedSpatialAnchorNamesMSFT")] + public unsafe partial Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] uint* spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] ref SpatialAnchorPersistenceNameMSFT persistedAnchorNames); + + /// To be documented. + [NativeApi(EntryPoint = "xrEnumeratePersistedSpatialAnchorNamesMSFT")] + public unsafe partial Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] ref uint spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] SpatialAnchorPersistenceNameMSFT* persistedAnchorNames); + + /// To be documented. + [NativeApi(EntryPoint = "xrEnumeratePersistedSpatialAnchorNamesMSFT")] + public partial Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] ref uint spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] ref SpatialAnchorPersistenceNameMSFT persistedAnchorNames); + + /// To be documented. + [NativeApi(EntryPoint = "xrPersistSpatialAnchorMSFT")] + public unsafe partial Result PersistSpatialAnchorMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0), Flow(FlowDirection.In)] SpatialAnchorPersistenceInfoMSFT* spatialAnchorPersistenceInfo); + + /// To be documented. + [NativeApi(EntryPoint = "xrPersistSpatialAnchorMSFT")] + public partial Result PersistSpatialAnchorMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0), Flow(FlowDirection.In)] in SpatialAnchorPersistenceInfoMSFT spatialAnchorPersistenceInfo); + + /// To be documented. + [NativeApi(EntryPoint = "xrUnpersistSpatialAnchorMSFT")] + public unsafe partial Result UnpersistSpatialAnchorMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0), Flow(FlowDirection.In)] SpatialAnchorPersistenceNameMSFT* spatialAnchorPersistenceName); + + /// To be documented. + [NativeApi(EntryPoint = "xrUnpersistSpatialAnchorMSFT")] + public partial Result UnpersistSpatialAnchorMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0), Flow(FlowDirection.In)] in SpatialAnchorPersistenceNameMSFT spatialAnchorPersistenceName); + + /// To be documented. + public unsafe Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint* spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] Span persistedAnchorNames) + { + // ImplicitCountSpanOverloader + return EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, (uint) persistedAnchorNames.Length, spatialAnchorNamesCountOutput, ref persistedAnchorNames.GetPinnableReference()); + } + + /// To be documented. + public unsafe Result EnumeratePersistedSpatialAnchorNamesMsft([Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] ref uint spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] Span persistedAnchorNames) + { + // ImplicitCountSpanOverloader + return EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, (uint) persistedAnchorNames.Length, ref spatialAnchorNamesCountOutput, ref persistedAnchorNames.GetPinnableReference()); + } + + public MsftSpatialAnchorPersistence(INativeContext ctx) + : base(ctx) + { + } + } +} + diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistenceOverloads.gen.cs b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistenceOverloads.gen.cs new file mode 100644 index 0000000000..fe64512e74 --- /dev/null +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.MSFT/MsftSpatialAnchorPersistenceOverloads.gen.cs @@ -0,0 +1,84 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR.Extensions.MSFT +{ + public static class MsftSpatialAnchorPersistenceOverloads + { + /// To be documented. + public static unsafe Result CreateSpatialAnchorFromPersistedNameMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] SpatialAnchorFromPersistedAnchorCreateInfoMSFT* spatialAnchorCreateInfo, [Count(Count = 0)] Span spatialAnchor) + { + // SpanOverloader + return thisApi.CreateSpatialAnchorFromPersistedNameMsft(session, spatialAnchorCreateInfo, ref spatialAnchor.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result CreateSpatialAnchorFromPersistedNameMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] ReadOnlySpan spatialAnchorCreateInfo, [Count(Count = 0)] SpatialAnchorMSFT* spatialAnchor) + { + // SpanOverloader + return thisApi.CreateSpatialAnchorFromPersistedNameMsft(session, in spatialAnchorCreateInfo.GetPinnableReference(), spatialAnchor); + } + + /// To be documented. + public static unsafe Result CreateSpatialAnchorFromPersistedNameMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] Session session, [Count(Count = 0), Flow(FlowDirection.In)] ReadOnlySpan spatialAnchorCreateInfo, [Count(Count = 0)] Span spatialAnchor) + { + // SpanOverloader + return thisApi.CreateSpatialAnchorFromPersistedNameMsft(session, in spatialAnchorCreateInfo.GetPinnableReference(), ref spatialAnchor.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result CreateSpatialAnchorStoreConnectionMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] Session session, [Count(Count = 0)] Span spatialAnchorStore) + { + // SpanOverloader + return thisApi.CreateSpatialAnchorStoreConnectionMsft(session, ref spatialAnchorStore.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result EnumeratePersistedSpatialAnchorNamesMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] uint* spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] Span persistedAnchorNames) + { + // SpanOverloader + return thisApi.EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, spatialAnchorNamesCapacityInput, spatialAnchorNamesCountOutput, ref persistedAnchorNames.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result EnumeratePersistedSpatialAnchorNamesMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] Span spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] SpatialAnchorPersistenceNameMSFT* persistedAnchorNames) + { + // SpanOverloader + return thisApi.EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, spatialAnchorNamesCapacityInput, ref spatialAnchorNamesCountOutput.GetPinnableReference(), persistedAnchorNames); + } + + /// To be documented. + public static unsafe Result EnumeratePersistedSpatialAnchorNamesMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0)] uint spatialAnchorNamesCapacityInput, [Count(Count = 0)] Span spatialAnchorNamesCountOutput, [Count(Parameter = "spatialAnchorNamesCapacityInput")] Span persistedAnchorNames) + { + // SpanOverloader + return thisApi.EnumeratePersistedSpatialAnchorNamesMsft(spatialAnchorStore, spatialAnchorNamesCapacityInput, ref spatialAnchorNamesCountOutput.GetPinnableReference(), ref persistedAnchorNames.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result PersistSpatialAnchorMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0), Flow(FlowDirection.In)] ReadOnlySpan spatialAnchorPersistenceInfo) + { + // SpanOverloader + return thisApi.PersistSpatialAnchorMsft(spatialAnchorStore, in spatialAnchorPersistenceInfo.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result UnpersistSpatialAnchorMsft(this MsftSpatialAnchorPersistence thisApi, [Count(Count = 0)] SpatialAnchorStoreConnectionMSFT spatialAnchorStore, [Count(Count = 0), Flow(FlowDirection.In)] ReadOnlySpan spatialAnchorPersistenceName) + { + // SpanOverloader + return thisApi.UnpersistSpatialAnchorMsft(spatialAnchorStore, in spatialAnchorPersistenceName.GetPinnableReference()); + } + + } +} + diff --git a/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.UNITY/Silk.NET.OpenXR.Extensions.UNITY.csproj b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.UNITY/Silk.NET.OpenXR.Extensions.UNITY.csproj new file mode 100644 index 0000000000..caa36148a5 --- /dev/null +++ b/src/OpenXR/Extensions/Silk.NET.OpenXR.Extensions.UNITY/Silk.NET.OpenXR.Extensions.UNITY.csproj @@ -0,0 +1,14 @@ + + + + netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0 + true + preview + + + + + + + + diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/BlendFactorFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/BlendFactorFB.gen.cs new file mode 100644 index 0000000000..255034f65a --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/BlendFactorFB.gen.cs @@ -0,0 +1,28 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrBlendFactorFB")] + public enum BlendFactorFB : int + { + [NativeName("Name", "XR_BLEND_FACTOR_ZERO_FB")] + BlendFactorZeroFB = 0, + [NativeName("Name", "XR_BLEND_FACTOR_ONE_FB")] + BlendFactorOneFB = 1, + [NativeName("Name", "XR_BLEND_FACTOR_SRC_ALPHA_FB")] + BlendFactorSrcAlphaFB = 2, + [NativeName("Name", "XR_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA_FB")] + BlendFactorOneMinusSrcAlphaFB = 3, + [NativeName("Name", "XR_BLEND_FACTOR_DST_ALPHA_FB")] + BlendFactorDstAlphaFB = 4, + [NativeName("Name", "XR_BLEND_FACTOR_ONE_MINUS_DST_ALPHA_FB")] + BlendFactorOneMinusDstAlphaFB = 5, + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/CompositionLayerImageLayoutFlagsFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/CompositionLayerImageLayoutFlagsFB.gen.cs new file mode 100644 index 0000000000..1649a3cf4c --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/CompositionLayerImageLayoutFlagsFB.gen.cs @@ -0,0 +1,19 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [Flags()] + [NativeName("Name", "XrCompositionLayerImageLayoutFlagsFB")] + public enum CompositionLayerImageLayoutFlagsFB : long + { + [NativeName("Name", "XR_COMPOSITION_LAYER_IMAGE_LAYOUT_VERTICAL_FLIP_BIT_FB")] + CompositionLayerImageLayoutVerticalFlipBitFB = 1, + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/CompositionLayerSecureContentFlagsFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/CompositionLayerSecureContentFlagsFB.gen.cs new file mode 100644 index 0000000000..728f28ff5e --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/CompositionLayerSecureContentFlagsFB.gen.cs @@ -0,0 +1,21 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [Flags()] + [NativeName("Name", "XrCompositionLayerSecureContentFlagsFB")] + public enum CompositionLayerSecureContentFlagsFB : long + { + [NativeName("Name", "XR_COMPOSITION_LAYER_SECURE_CONTENT_EXCLUDE_LAYER_BIT_FB")] + CompositionLayerSecureContentExcludeLayerBitFB = 1, + [NativeName("Name", "XR_COMPOSITION_LAYER_SECURE_CONTENT_REPLACE_LAYER_BIT_FB")] + CompositionLayerSecureContentReplaceLayerBitFB = 2, + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/FoveationDynamicFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/FoveationDynamicFB.gen.cs new file mode 100644 index 0000000000..609619f02d --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/FoveationDynamicFB.gen.cs @@ -0,0 +1,20 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrFoveationDynamicFB")] + public enum FoveationDynamicFB : int + { + [NativeName("Name", "XR_FOVEATION_DYNAMIC_DISABLED_FB")] + FoveationDynamicDisabledFB = 0, + [NativeName("Name", "XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_FB")] + FoveationDynamicLevelEnabledFB = 1, + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/FoveationLevelFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/FoveationLevelFB.gen.cs new file mode 100644 index 0000000000..e85e87a5e4 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/FoveationLevelFB.gen.cs @@ -0,0 +1,24 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrFoveationLevelFB")] + public enum FoveationLevelFB : int + { + [NativeName("Name", "XR_FOVEATION_LEVEL_NONE_FB")] + FoveationLevelNoneFB = 0, + [NativeName("Name", "XR_FOVEATION_LEVEL_LOW_FB")] + FoveationLevelLowFB = 1, + [NativeName("Name", "XR_FOVEATION_LEVEL_MEDIUM_FB")] + FoveationLevelMediumFB = 2, + [NativeName("Name", "XR_FOVEATION_LEVEL_HIGH_FB")] + FoveationLevelHighFB = 3, + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/ObjectType.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/ObjectType.gen.cs index 348e844aa2..4c6a390d36 100644 --- a/src/OpenXR/Silk.NET.OpenXR/Enums/ObjectType.gen.cs +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/ObjectType.gen.cs @@ -36,5 +36,9 @@ public enum ObjectType : int SceneObserverMsft = 1000097000, [NativeName("Name", "XR_OBJECT_TYPE_SCENE_MSFT")] SceneMsft = 1000097001, + [NativeName("Name", "XR_OBJECT_TYPE_FOVEATION_PROFILE_FB")] + FoveationProfileFB = 1000114000, + [NativeName("Name", "XR_OBJECT_TYPE_SPATIAL_ANCHOR_STORE_CONNECTION_MSFT")] + SpatialAnchorStoreConnectionMsft = 1000142000, } } diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/Result.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/Result.gen.cs index 6b26ba3c31..59747bf4c9 100644 --- a/src/OpenXR/Silk.NET.OpenXR/Enums/Result.gen.cs +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/Result.gen.cs @@ -150,5 +150,9 @@ public enum Result : int ErrorDisplayRefreshRateUnsupportedFB = -1000101000, [NativeName("Name", "XR_ERROR_COLOR_SPACE_UNSUPPORTED_FB")] ErrorColorSpaceUnsupportedFB = -1000108000, + [NativeName("Name", "XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT")] + ErrorSpatialAnchorNameNotFoundMsft = -1000142001, + [NativeName("Name", "XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT")] + ErrorSpatialAnchorNameInvalidMsft = -1000142002, } } diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/StructureType.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/StructureType.gen.cs index 8ff5270512..864b5ab51e 100644 --- a/src/OpenXR/Silk.NET.OpenXR/Enums/StructureType.gen.cs +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/StructureType.gen.cs @@ -188,6 +188,10 @@ public enum StructureType : int TypeSpatialAnchorCreateInfoMsft = 1000039000, [NativeName("Name", "XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT")] TypeSpatialAnchorSpaceCreateInfoMsft = 1000039001, + [NativeName("Name", "XR_TYPE_COMPOSITION_LAYER_IMAGE_LAYOUT_FB")] + TypeCompositionLayerImageLayoutFB = 1000040000, + [NativeName("Name", "XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB")] + TypeCompositionLayerAlphaBlendFB = 1000041001, [NativeName("Name", "XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT")] TypeViewConfigurationDepthRangeExt = 1000046000, [NativeName("Name", "XR_TYPE_GRAPHICS_BINDING_EGL_MNDX")] @@ -246,6 +250,8 @@ public enum StructureType : int TypeCompositionLayerReprojectionPlaneOverrideMsft = 1000066001, [NativeName("Name", "XR_TYPE_ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB")] TypeAndroidSurfaceSwapchainCreateInfoFB = 1000070000, + [NativeName("Name", "XR_TYPE_COMPOSITION_LAYER_SECURE_CONTENT_FB")] + TypeCompositionLayerSecureContentFB = 1000072000, [NativeName("Name", "XR_TYPE_INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE")] TypeInteractionProfileAnalogThresholdValve = 1000079000, [NativeName("Name", "XR_TYPE_HAND_JOINTS_MOTION_RANGE_INFO_EXT")] @@ -312,6 +318,14 @@ public enum StructureType : int TypeEventDataDisplayRefreshRateChangedFB = 1000101000, [NativeName("Name", "XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB")] TypeSystemColorSpacePropertiesFB = 1000108000, + [NativeName("Name", "XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB")] + TypeFoveationProfileCreateInfoFB = 1000114000, + [NativeName("Name", "XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB")] + TypeSwapchainCreateInfoFoveationFB = 1000114001, + [NativeName("Name", "XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB")] + TypeSwapchainStateFoveationFB = 1000114002, + [NativeName("Name", "XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB")] + TypeFoveationLevelProfileCreateInfoFB = 1000115000, [NativeName("Name", "XR_TYPE_BINDING_MODIFICATIONS_KHR")] TypeBindingModificationsKhr = 1000120000, [NativeName("Name", "XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO")] @@ -322,6 +336,12 @@ public enum StructureType : int TypeSystemFoveatedRenderingPropertiesVarjo = 1000121002, [NativeName("Name", "XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO")] TypeCompositionLayerDepthTestVarjo = 1000122000, + [NativeName("Name", "XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT")] + TypeSpatialAnchorPersistenceInfoMsft = 1000142000, + [NativeName("Name", "XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT")] + TypeSpatialAnchorFromPersistedAnchorCreateInfoMsft = 1000142001, + [NativeName("Name", "XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB")] + TypeSwapchainImageFoveationVulkanFB = 1000160000, [NativeName("Name", "XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB")] TypeSwapchainStateAndroidSurfaceDimensionsFB = 1000161000, [NativeName("Name", "XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB")] diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/SwapchainCreateFoveationFlagsFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/SwapchainCreateFoveationFlagsFB.gen.cs new file mode 100644 index 0000000000..ebf51d7680 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/SwapchainCreateFoveationFlagsFB.gen.cs @@ -0,0 +1,21 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [Flags()] + [NativeName("Name", "XrSwapchainCreateFoveationFlagsFB")] + public enum SwapchainCreateFoveationFlagsFB : long + { + [NativeName("Name", "XR_SWAPCHAIN_CREATE_FOVEATION_SCALED_BIN_BIT_FB")] + SwapchainCreateFoveationScaledBinBitFB = 1, + [NativeName("Name", "XR_SWAPCHAIN_CREATE_FOVEATION_FRAGMENT_DENSITY_MAP_BIT_FB")] + SwapchainCreateFoveationFragmentDensityMapBitFB = 2, + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/SwapchainStateFoveationFlagsFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/SwapchainStateFoveationFlagsFB.gen.cs new file mode 100644 index 0000000000..11edb00ace --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/SwapchainStateFoveationFlagsFB.gen.cs @@ -0,0 +1,17 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [Flags()] + [NativeName("Name", "XrSwapchainStateFoveationFlagsFB")] + public enum SwapchainStateFoveationFlagsFB : long + { + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Enums/SwapchainUsageFlags.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Enums/SwapchainUsageFlags.gen.cs index dd2b2aebd9..a351d38de5 100644 --- a/src/OpenXR/Silk.NET.OpenXR/Enums/SwapchainUsageFlags.gen.cs +++ b/src/OpenXR/Silk.NET.OpenXR/Enums/SwapchainUsageFlags.gen.cs @@ -29,5 +29,7 @@ public enum SwapchainUsageFlags : long SwapchainUsageMutableFormatBit = 64, [NativeName("Name", "XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND")] SwapchainUsageInputAttachmentBitMnd = 128, + [NativeName("Name", "XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_KHR")] + SwapchainUsageInputAttachmentBitKhr = 128, } } diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/CompositionLayerAlphaBlendFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/CompositionLayerAlphaBlendFB.gen.cs new file mode 100644 index 0000000000..e090159e7a --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/CompositionLayerAlphaBlendFB.gen.cs @@ -0,0 +1,94 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrCompositionLayerAlphaBlendFB")] + public unsafe partial struct CompositionLayerAlphaBlendFB + { + public CompositionLayerAlphaBlendFB + ( + StructureType? type = StructureType.TypeCompositionLayerAlphaBlendFB, + void* next = null, + BlendFactorFB? srcFactorColor = null, + BlendFactorFB? dstFactorColor = null, + BlendFactorFB? srcFactorAlpha = null, + BlendFactorFB? dstFactorAlpha = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (srcFactorColor is not null) + { + SrcFactorColor = srcFactorColor.Value; + } + + if (dstFactorColor is not null) + { + DstFactorColor = dstFactorColor.Value; + } + + if (srcFactorAlpha is not null) + { + SrcFactorAlpha = srcFactorAlpha.Value; + } + + if (dstFactorAlpha is not null) + { + DstFactorAlpha = dstFactorAlpha.Value; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "XrBlendFactorFB")] + [NativeName("Type.Name", "XrBlendFactorFB")] + [NativeName("Name", "srcFactorColor")] + public BlendFactorFB SrcFactorColor; +/// + [NativeName("Type", "XrBlendFactorFB")] + [NativeName("Type.Name", "XrBlendFactorFB")] + [NativeName("Name", "dstFactorColor")] + public BlendFactorFB DstFactorColor; +/// + [NativeName("Type", "XrBlendFactorFB")] + [NativeName("Type.Name", "XrBlendFactorFB")] + [NativeName("Name", "srcFactorAlpha")] + public BlendFactorFB SrcFactorAlpha; +/// + [NativeName("Type", "XrBlendFactorFB")] + [NativeName("Type.Name", "XrBlendFactorFB")] + [NativeName("Name", "dstFactorAlpha")] + public BlendFactorFB DstFactorAlpha; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/CompositionLayerImageLayoutFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/CompositionLayerImageLayoutFB.gen.cs new file mode 100644 index 0000000000..c12906c3e8 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/CompositionLayerImageLayoutFB.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrCompositionLayerImageLayoutFB")] + public unsafe partial struct CompositionLayerImageLayoutFB + { + public CompositionLayerImageLayoutFB + ( + StructureType? type = StructureType.TypeCompositionLayerImageLayoutFB, + void* next = null, + CompositionLayerImageLayoutFlagsFB? flags = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (flags is not null) + { + Flags = flags.Value; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "XrCompositionLayerImageLayoutFlagsFB")] + [NativeName("Type.Name", "XrCompositionLayerImageLayoutFlagsFB")] + [NativeName("Name", "flags")] + public CompositionLayerImageLayoutFlagsFB Flags; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/CompositionLayerSecureContentFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/CompositionLayerSecureContentFB.gen.cs new file mode 100644 index 0000000000..d2edc83376 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/CompositionLayerSecureContentFB.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrCompositionLayerSecureContentFB")] + public unsafe partial struct CompositionLayerSecureContentFB + { + public CompositionLayerSecureContentFB + ( + StructureType? type = StructureType.TypeCompositionLayerSecureContentFB, + void* next = null, + CompositionLayerSecureContentFlagsFB? flags = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (flags is not null) + { + Flags = flags.Value; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "XrCompositionLayerSecureContentFlagsFB")] + [NativeName("Type.Name", "XrCompositionLayerSecureContentFlagsFB")] + [NativeName("Name", "flags")] + public CompositionLayerSecureContentFlagsFB Flags; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/FoveationLevelProfileCreateInfoFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/FoveationLevelProfileCreateInfoFB.gen.cs new file mode 100644 index 0000000000..32fe4dc662 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/FoveationLevelProfileCreateInfoFB.gen.cs @@ -0,0 +1,83 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrFoveationLevelProfileCreateInfoFB")] + public unsafe partial struct FoveationLevelProfileCreateInfoFB + { + public FoveationLevelProfileCreateInfoFB + ( + StructureType? type = StructureType.TypeFoveationLevelProfileCreateInfoFB, + void* next = null, + FoveationLevelFB? level = null, + float? verticalOffset = null, + FoveationDynamicFB? dynamic = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (level is not null) + { + Level = level.Value; + } + + if (verticalOffset is not null) + { + VerticalOffset = verticalOffset.Value; + } + + if (dynamic is not null) + { + Dynamic = dynamic.Value; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "XrFoveationLevelFB")] + [NativeName("Type.Name", "XrFoveationLevelFB")] + [NativeName("Name", "level")] + public FoveationLevelFB Level; +/// + [NativeName("Type", "float")] + [NativeName("Type.Name", "float")] + [NativeName("Name", "verticalOffset")] + public float VerticalOffset; +/// + [NativeName("Type", "XrFoveationDynamicFB")] + [NativeName("Type.Name", "XrFoveationDynamicFB")] + [NativeName("Name", "dynamic")] + public FoveationDynamicFB Dynamic; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/FoveationProfileCreateInfoFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/FoveationProfileCreateInfoFB.gen.cs new file mode 100644 index 0000000000..5dda414d55 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/FoveationProfileCreateInfoFB.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrFoveationProfileCreateInfoFB")] + public unsafe partial struct FoveationProfileCreateInfoFB + { + public FoveationProfileCreateInfoFB + ( + StructureType? type = StructureType.TypeFoveationProfileCreateInfoFB, + void* next = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/FoveationProfileFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/FoveationProfileFB.gen.cs new file mode 100644 index 0000000000..ccbf8bb40d --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/FoveationProfileFB.gen.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrFoveationProfileFB")] + public unsafe partial struct FoveationProfileFB + { + public FoveationProfileFB + ( + ulong? handle = null + ) : this() + { + if (handle is not null) + { + Handle = handle.Value; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "")] + public ulong Handle; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorFromPersistedAnchorCreateInfoMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorFromPersistedAnchorCreateInfoMSFT.gen.cs new file mode 100644 index 0000000000..4f4dbe26e3 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorFromPersistedAnchorCreateInfoMSFT.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT")] + public unsafe partial struct SpatialAnchorFromPersistedAnchorCreateInfoMSFT + { + public SpatialAnchorFromPersistedAnchorCreateInfoMSFT + ( + StructureType? type = StructureType.TypeSpatialAnchorFromPersistedAnchorCreateInfoMsft, + void* next = null, + SpatialAnchorStoreConnectionMSFT? spatialAnchorStore = null, + SpatialAnchorPersistenceNameMSFT? spatialAnchorPersistenceName = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (spatialAnchorStore is not null) + { + SpatialAnchorStore = spatialAnchorStore.Value; + } + + if (spatialAnchorPersistenceName is not null) + { + SpatialAnchorPersistenceName = spatialAnchorPersistenceName.Value; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "XrSpatialAnchorStoreConnectionMSFT")] + [NativeName("Type.Name", "XrSpatialAnchorStoreConnectionMSFT")] + [NativeName("Name", "spatialAnchorStore")] + public SpatialAnchorStoreConnectionMSFT SpatialAnchorStore; +/// + [NativeName("Type", "XrSpatialAnchorPersistenceNameMSFT")] + [NativeName("Type.Name", "XrSpatialAnchorPersistenceNameMSFT")] + [NativeName("Name", "spatialAnchorPersistenceName")] + public SpatialAnchorPersistenceNameMSFT SpatialAnchorPersistenceName; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorPersistenceInfoMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorPersistenceInfoMSFT.gen.cs new file mode 100644 index 0000000000..bdfaa7cfe7 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorPersistenceInfoMSFT.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSpatialAnchorPersistenceInfoMSFT")] + public unsafe partial struct SpatialAnchorPersistenceInfoMSFT + { + public SpatialAnchorPersistenceInfoMSFT + ( + StructureType? type = StructureType.TypeSpatialAnchorPersistenceInfoMsft, + void* next = null, + SpatialAnchorPersistenceNameMSFT? spatialAnchorPersistenceName = null, + SpatialAnchorMSFT? spatialAnchor = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (spatialAnchorPersistenceName is not null) + { + SpatialAnchorPersistenceName = spatialAnchorPersistenceName.Value; + } + + if (spatialAnchor is not null) + { + SpatialAnchor = spatialAnchor.Value; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "XrSpatialAnchorPersistenceNameMSFT")] + [NativeName("Type.Name", "XrSpatialAnchorPersistenceNameMSFT")] + [NativeName("Name", "spatialAnchorPersistenceName")] + public SpatialAnchorPersistenceNameMSFT SpatialAnchorPersistenceName; +/// + [NativeName("Type", "XrSpatialAnchorMSFT")] + [NativeName("Type.Name", "XrSpatialAnchorMSFT")] + [NativeName("Name", "spatialAnchor")] + public SpatialAnchorMSFT SpatialAnchor; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorPersistenceNameMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorPersistenceNameMSFT.gen.cs new file mode 100644 index 0000000000..3d2ec8ff61 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorPersistenceNameMSFT.gen.cs @@ -0,0 +1,28 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSpatialAnchorPersistenceNameMSFT")] + public unsafe partial struct SpatialAnchorPersistenceNameMSFT + { + /// + [NativeName("Type", "char")] + [NativeName("Type.Name", "char")] + [NativeName("Name", "name")] + public fixed byte Name[256]; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorStoreConnectionMSFT.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorStoreConnectionMSFT.gen.cs new file mode 100644 index 0000000000..4fa37c5b82 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/SpatialAnchorStoreConnectionMSFT.gen.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSpatialAnchorStoreConnectionMSFT")] + public unsafe partial struct SpatialAnchorStoreConnectionMSFT + { + public SpatialAnchorStoreConnectionMSFT + ( + ulong? handle = null + ) : this() + { + if (handle is not null) + { + Handle = handle.Value; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "")] + public ulong Handle; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/SwapchainCreateInfoFoveationFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/SwapchainCreateInfoFoveationFB.gen.cs new file mode 100644 index 0000000000..46f6c0267c --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/SwapchainCreateInfoFoveationFB.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSwapchainCreateInfoFoveationFB")] + public unsafe partial struct SwapchainCreateInfoFoveationFB + { + public SwapchainCreateInfoFoveationFB + ( + StructureType? type = StructureType.TypeSwapchainCreateInfoFoveationFB, + void* next = null, + SwapchainCreateFoveationFlagsFB? flags = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (flags is not null) + { + Flags = flags.Value; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "XrSwapchainCreateFoveationFlagsFB")] + [NativeName("Type.Name", "XrSwapchainCreateFoveationFlagsFB")] + [NativeName("Name", "flags")] + public SwapchainCreateFoveationFlagsFB Flags; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/SwapchainImageFoveationVulkanFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/SwapchainImageFoveationVulkanFB.gen.cs new file mode 100644 index 0000000000..e7906adde0 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/SwapchainImageFoveationVulkanFB.gen.cs @@ -0,0 +1,83 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSwapchainImageFoveationVulkanFB")] + public unsafe partial struct SwapchainImageFoveationVulkanFB + { + public SwapchainImageFoveationVulkanFB + ( + StructureType? type = StructureType.TypeSwapchainImageFoveationVulkanFB, + void* next = null, + ulong? image = null, + uint? width = null, + uint? height = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (image is not null) + { + Image = image.Value; + } + + if (width is not null) + { + Width = width.Value; + } + + if (height is not null) + { + Height = height.Value; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "VkImage")] + [NativeName("Type.Name", "VkImage")] + [NativeName("Name", "image")] + public ulong Image; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "width")] + public uint Width; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "height")] + public uint Height; + } +} diff --git a/src/OpenXR/Silk.NET.OpenXR/Structs/SwapchainStateFoveationFB.gen.cs b/src/OpenXR/Silk.NET.OpenXR/Structs/SwapchainStateFoveationFB.gen.cs new file mode 100644 index 0000000000..9d6277bc11 --- /dev/null +++ b/src/OpenXR/Silk.NET.OpenXR/Structs/SwapchainStateFoveationFB.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.OpenXR +{ + [NativeName("Name", "XrSwapchainStateFoveationFB")] + public unsafe partial struct SwapchainStateFoveationFB + { + public SwapchainStateFoveationFB + ( + StructureType? type = StructureType.TypeSwapchainStateFoveationFB, + void* next = null, + SwapchainStateFoveationFlagsFB? flags = null, + FoveationProfileFB? profile = null + ) : this() + { + if (type is not null) + { + Type = type.Value; + } + + if (next is not null) + { + Next = next; + } + + if (flags is not null) + { + Flags = flags.Value; + } + + if (profile is not null) + { + Profile = profile.Value; + } + } + +/// + [NativeName("Type", "XrStructureType")] + [NativeName("Type.Name", "XrStructureType")] + [NativeName("Name", "type")] + public StructureType Type; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "next")] + public void* Next; +/// + [NativeName("Type", "XrSwapchainStateFoveationFlagsFB")] + [NativeName("Type.Name", "XrSwapchainStateFoveationFlagsFB")] + [NativeName("Name", "flags")] + public SwapchainStateFoveationFlagsFB Flags; +/// + [NativeName("Type", "XrFoveationProfileFB")] + [NativeName("Type.Name", "XrFoveationProfileFB")] + [NativeName("Name", "profile")] + public FoveationProfileFB Profile; + } +} diff --git a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.HUAWEI/HuaweiInvocationMask.gen.cs b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.HUAWEI/HuaweiInvocationMask.gen.cs new file mode 100644 index 0000000000..2b12877219 --- /dev/null +++ b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.HUAWEI/HuaweiInvocationMask.gen.cs @@ -0,0 +1,33 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; +using Silk.NET.Vulkan; +using Extension = Silk.NET.Core.Attributes.ExtensionAttribute; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan.Extensions.HUAWEI +{ + [Extension("VK_HUAWEI_invocation_mask")] + public unsafe partial class HuaweiInvocationMask : NativeExtension + { + public const string ExtensionName = "VK_HUAWEI_invocation_mask"; + /// To be documented. + [NativeApi(EntryPoint = "vkCmdBindInvocationMaskHUAWEI")] + public partial void CmdBindInvocationMaskHuawei([Count(Count = 0)] CommandBuffer commandBuffer, [Count(Count = 0)] ImageView imageView, [Count(Count = 0)] ImageLayout imageLayout); + + public HuaweiInvocationMask(INativeContext ctx) + : base(ctx) + { + } + } +} + diff --git a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.HUAWEI/HuaweiSubpassShading.gen.cs b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.HUAWEI/HuaweiSubpassShading.gen.cs index c5254a5ff0..76fdea8ccb 100644 --- a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.HUAWEI/HuaweiSubpassShading.gen.cs +++ b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.HUAWEI/HuaweiSubpassShading.gen.cs @@ -25,12 +25,12 @@ public unsafe partial class HuaweiSubpassShading : NativeExtension public partial void CmdSubpassShadingHuawei([Count(Count = 0)] CommandBuffer commandBuffer); /// To be documented. - [NativeApi(EntryPoint = "vkGetSubpassShadingMaxWorkgroupSizeHUAWEI")] - public unsafe partial Result GetSubpassShadingMaxWorkgroupSizeHuawei([Count(Count = 0)] RenderPass renderpass, [Count(Count = 0), Flow(FlowDirection.Out)] Extent2D* pMaxWorkgroupSize); + [NativeApi(EntryPoint = "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")] + public unsafe partial Result GetDeviceSubpassShadingMaxWorkgroupSizeHuawei([Count(Count = 0)] Device device, [Count(Count = 0)] RenderPass renderpass, [Count(Count = 0), Flow(FlowDirection.Out)] Extent2D* pMaxWorkgroupSize); /// To be documented. - [NativeApi(EntryPoint = "vkGetSubpassShadingMaxWorkgroupSizeHUAWEI")] - public partial Result GetSubpassShadingMaxWorkgroupSizeHuawei([Count(Count = 0)] RenderPass renderpass, [Count(Count = 0), Flow(FlowDirection.Out)] out Extent2D pMaxWorkgroupSize); + [NativeApi(EntryPoint = "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")] + public partial Result GetDeviceSubpassShadingMaxWorkgroupSizeHuawei([Count(Count = 0)] Device device, [Count(Count = 0)] RenderPass renderpass, [Count(Count = 0), Flow(FlowDirection.Out)] out Extent2D pMaxWorkgroupSize); public HuaweiSubpassShading(INativeContext ctx) : base(ctx) diff --git a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.HUAWEI/HuaweiSubpassShadingOverloads.gen.cs b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.HUAWEI/HuaweiSubpassShadingOverloads.gen.cs index 11c2bddbc7..95e19a82c4 100644 --- a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.HUAWEI/HuaweiSubpassShadingOverloads.gen.cs +++ b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.HUAWEI/HuaweiSubpassShadingOverloads.gen.cs @@ -17,10 +17,10 @@ namespace Silk.NET.Vulkan.Extensions.HUAWEI public static class HuaweiSubpassShadingOverloads { /// To be documented. - public static unsafe Result GetSubpassShadingMaxWorkgroupSizeHuawei(this HuaweiSubpassShading thisApi, [Count(Count = 0)] RenderPass renderpass, [Count(Count = 0), Flow(FlowDirection.Out)] Span pMaxWorkgroupSize) + public static unsafe Result GetDeviceSubpassShadingMaxWorkgroupSizeHuawei(this HuaweiSubpassShading thisApi, [Count(Count = 0)] Device device, [Count(Count = 0)] RenderPass renderpass, [Count(Count = 0), Flow(FlowDirection.Out)] Span pMaxWorkgroupSize) { // SpanOverloader - return thisApi.GetSubpassShadingMaxWorkgroupSizeHuawei(renderpass, out pMaxWorkgroupSize.GetPinnableReference()); + return thisApi.GetDeviceSubpassShadingMaxWorkgroupSizeHuawei(device, renderpass, out pMaxWorkgroupSize.GetPinnableReference()); } } diff --git a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.KHR/KhrPresentWait.gen.cs b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.KHR/KhrPresentWait.gen.cs new file mode 100644 index 0000000000..d3b651f04b --- /dev/null +++ b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.KHR/KhrPresentWait.gen.cs @@ -0,0 +1,33 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; +using Silk.NET.Vulkan; +using Extension = Silk.NET.Core.Attributes.ExtensionAttribute; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan.Extensions.KHR +{ + [Extension("VK_KHR_present_wait")] + public unsafe partial class KhrPresentWait : NativeExtension + { + public const string ExtensionName = "VK_KHR_present_wait"; + /// To be documented. + [NativeApi(EntryPoint = "vkWaitForPresentKHR")] + public partial Result WaitForPresent([Count(Count = 0)] Device device, [Count(Count = 0)] SwapchainKHR swapchain, [Count(Count = 0)] ulong presentId, [Count(Count = 0)] ulong timeout); + + public KhrPresentWait(INativeContext ctx) + : base(ctx) + { + } + } +} + diff --git a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVExternalMemoryRdma.gen.cs b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVExternalMemoryRdma.gen.cs new file mode 100644 index 0000000000..b13d112650 --- /dev/null +++ b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVExternalMemoryRdma.gen.cs @@ -0,0 +1,45 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; +using Silk.NET.Vulkan; +using Extension = Silk.NET.Core.Attributes.ExtensionAttribute; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan.Extensions.NV +{ + [Extension("VK_NV_external_memory_rdma")] + public unsafe partial class NVExternalMemoryRdma : NativeExtension + { + public const string ExtensionName = "VK_NV_external_memory_rdma"; + /// To be documented. + [NativeApi(EntryPoint = "vkGetMemoryRemoteAddressNV")] + public unsafe partial Result GetMemoryRemoteAddress([Count(Count = 0)] Device device, [Count(Count = 0), Flow(FlowDirection.In)] MemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, [Count(Count = 0), Flow(FlowDirection.Out)] void* pAddress); + + /// To be documented. + [NativeApi(EntryPoint = "vkGetMemoryRemoteAddressNV")] + public unsafe partial Result GetMemoryRemoteAddress([Count(Count = 0)] Device device, [Count(Count = 0), Flow(FlowDirection.In)] MemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, [Count(Count = 0), Flow(FlowDirection.Out)] out T0 pAddress) where T0 : unmanaged; + + /// To be documented. + [NativeApi(EntryPoint = "vkGetMemoryRemoteAddressNV")] + public unsafe partial Result GetMemoryRemoteAddress([Count(Count = 0)] Device device, [Count(Count = 0), Flow(FlowDirection.In)] in MemoryGetRemoteAddressInfoNV pMemoryGetRemoteAddressInfo, [Count(Count = 0), Flow(FlowDirection.Out)] void* pAddress); + + /// To be documented. + [NativeApi(EntryPoint = "vkGetMemoryRemoteAddressNV")] + public partial Result GetMemoryRemoteAddress([Count(Count = 0)] Device device, [Count(Count = 0), Flow(FlowDirection.In)] in MemoryGetRemoteAddressInfoNV pMemoryGetRemoteAddressInfo, [Count(Count = 0), Flow(FlowDirection.Out)] out T0 pAddress) where T0 : unmanaged; + + public NVExternalMemoryRdma(INativeContext ctx) + : base(ctx) + { + } + } +} + diff --git a/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVExternalMemoryRdmaOverloads.gen.cs b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVExternalMemoryRdmaOverloads.gen.cs new file mode 100644 index 0000000000..3e36be16b4 --- /dev/null +++ b/src/Vulkan/Extensions/Silk.NET.Vulkan.Extensions.NV/NVExternalMemoryRdmaOverloads.gen.cs @@ -0,0 +1,42 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan.Extensions.NV +{ + public static class NVExternalMemoryRdmaOverloads + { + /// To be documented. + public static unsafe Result GetMemoryRemoteAddress(this NVExternalMemoryRdma thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(FlowDirection.In)] MemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, [Count(Count = 0), Flow(FlowDirection.Out)] Span pAddress) where T0 : unmanaged + { + // SpanOverloader + return thisApi.GetMemoryRemoteAddress(device, pMemoryGetRemoteAddressInfo, out pAddress.GetPinnableReference()); + } + + /// To be documented. + public static unsafe Result GetMemoryRemoteAddress(this NVExternalMemoryRdma thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(FlowDirection.In)] ReadOnlySpan pMemoryGetRemoteAddressInfo, [Count(Count = 0), Flow(FlowDirection.Out)] void* pAddress) + { + // SpanOverloader + return thisApi.GetMemoryRemoteAddress(device, in pMemoryGetRemoteAddressInfo.GetPinnableReference(), pAddress); + } + + /// To be documented. + public static unsafe Result GetMemoryRemoteAddress(this NVExternalMemoryRdma thisApi, [Count(Count = 0)] Device device, [Count(Count = 0), Flow(FlowDirection.In)] ReadOnlySpan pMemoryGetRemoteAddressInfo, [Count(Count = 0), Flow(FlowDirection.Out)] Span pAddress) where T0 : unmanaged + { + // SpanOverloader + return thisApi.GetMemoryRemoteAddress(device, in pMemoryGetRemoteAddressInfo.GetPinnableReference(), out pAddress.GetPinnableReference()); + } + + } +} + diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/AccessFlags2KHR.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/AccessFlags2KHR.gen.cs index 79c148a0ae..c7ea7672e6 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/AccessFlags2KHR.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/AccessFlags2KHR.gen.cs @@ -91,7 +91,7 @@ public enum AccessFlags2KHR : long Access2FragmentDensityMapReadBitExt = 16777216, [NativeName("Name", "VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT")] Access2ColorAttachmentReadNoncoherentBitExt = 524288, - [NativeName("Name", "VK_ACCESS_2_RESERVED_39_BIT_HUAWEI")] - Access2Reserved39BitHuawei = 549755813888, + [NativeName("Name", "VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI")] + Access2InvocationMaskReadBitHuawei = 549755813888, } } diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/ExternalMemoryHandleTypeFlags.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/ExternalMemoryHandleTypeFlags.gen.cs index 800228a3a1..05db1d7ed5 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/ExternalMemoryHandleTypeFlags.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/ExternalMemoryHandleTypeFlags.gen.cs @@ -37,8 +37,8 @@ public enum ExternalMemoryHandleTypeFlags : int ExternalMemoryHandleTypeHostMappedForeignMemoryBitExt = 256, [NativeName("Name", "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA")] ExternalMemoryHandleTypeZirconVmoBitFuchsia = 2048, - [NativeName("Name", "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RESERVED_12_BIT_NV")] - ExternalMemoryHandleTypeReserved12BitNV = 4096, + [NativeName("Name", "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV")] + ExternalMemoryHandleTypeRdmaAddressBitNV = 4096, [NativeName("Name", "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RESERVED_13_BIT_NV")] ExternalMemoryHandleTypeReserved13BitNV = 8192, } diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/ImageUsageFlags.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/ImageUsageFlags.gen.cs index 4f30469cec..37be88921c 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/ImageUsageFlags.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/ImageUsageFlags.gen.cs @@ -51,7 +51,9 @@ public enum ImageUsageFlags : int ImageUsageVideoEncodeSrcBitKhr = 16384, [NativeName("Name", "VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR")] ImageUsageVideoEncodeDpbBitKhr = 32768, - [NativeName("Name", "VK_IMAGE_USAGE_RESERVED_18_BIT_HUAWEI")] - ImageUsageReserved18BitHuawei = 262144, + [NativeName("Name", "VK_IMAGE_USAGE_RESERVED_19_BIT_EXT")] + ImageUsageReserved19BitExt = 524288, + [NativeName("Name", "VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI")] + ImageUsageInvocationMaskBitHuawei = 262144, } } diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/MemoryPropertyFlags.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/MemoryPropertyFlags.gen.cs index de381cede4..e829a738d4 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/MemoryPropertyFlags.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/MemoryPropertyFlags.gen.cs @@ -27,8 +27,8 @@ public enum MemoryPropertyFlags : int MemoryPropertyDeviceCoherentBitAmd = 64, [NativeName("Name", "VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD")] MemoryPropertyDeviceUncachedBitAmd = 128, - [NativeName("Name", "VK_MEMORY_PROPERTY_RESERVED_8_BIT_NV")] - MemoryPropertyReserved8BitNV = 256, + [NativeName("Name", "VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV")] + MemoryPropertyRdmaCapableBitNV = 256, [NativeName("Name", "VK_MEMORY_PROPERTY_PROTECTED_BIT")] MemoryPropertyProtectedBit = 32, } diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/PipelineStageFlags2KHR.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/PipelineStageFlags2KHR.gen.cs index 6e8b55ae7f..54003d42fd 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/PipelineStageFlags2KHR.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/PipelineStageFlags2KHR.gen.cs @@ -95,7 +95,7 @@ public enum PipelineStageFlags2KHR : long PipelineStage2MeshShaderBitNV = 1048576, [NativeName("Name", "VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI")] PipelineStage2SubpassShadingBitHuawei = 549755813888, - [NativeName("Name", "VK_PIPELINE_STAGE_2_RESERVED_40_BIT_HUAWEI")] - PipelineStage2Reserved40BitHuawei = 1099511627776, + [NativeName("Name", "VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI")] + PipelineStage2InvocationMaskBitHuawei = 1099511627776, } } diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/StructureType.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/StructureType.gen.cs index 1d4685bf46..dfa23c7b0f 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/StructureType.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/StructureType.gen.cs @@ -882,6 +882,8 @@ public enum StructureType : int ImageStencilUsageCreateInfoExt = 1000246000, [NativeName("Name", "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT")] ValidationFeaturesExt = 1000247000, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR")] + PhysicalDevicePresentWaitFeaturesKhr = 1000248000, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV")] PhysicalDeviceCooperativeMatrixFeaturesNV = 1000249000, [NativeName("Name", "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV")] @@ -950,6 +952,8 @@ public enum StructureType : int PipelineExecutableStatisticKhr = 1000269004, [NativeName("Name", "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR")] PipelineExecutableInternalRepresentationKhr = 1000269005, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT")] + PhysicalDeviceShaderAtomicFloat2FeaturesExt = 1000273000, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT")] PhysicalDeviceShaderDemoteToHelperInvocationFeaturesExt = 1000276000, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV")] @@ -998,6 +1002,10 @@ public enum StructureType : int PhysicalDeviceCustomBorderColorFeaturesExt = 1000287002, [NativeName("Name", "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR")] PipelineLibraryCreateInfoKhr = 1000290000, + [NativeName("Name", "VK_STRUCTURE_TYPE_PRESENT_ID_KHR")] + PresentIDKhr = 1000294000, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR")] + PhysicalDevicePresentIDFeaturesKhr = 1000294001, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT")] PhysicalDevicePrivateDataFeaturesExt = 1000295000, [NativeName("Name", "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT")] @@ -1118,6 +1126,12 @@ public enum StructureType : int PhysicalDeviceSubpassShadingFeaturesHuawei = 1000369001, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI")] PhysicalDeviceSubpassShadingPropertiesHuawei = 1000369002, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI")] + PhysicalDeviceInvocationMaskFeaturesHuawei = 1000370000, + [NativeName("Name", "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV")] + MemoryGetRemoteAddressInfoNV = 1000371000, + [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV")] + PhysicalDeviceExternalMemoryRdmaFeaturesNV = 1000371001, [NativeName("Name", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT")] PhysicalDeviceExtendedDynamicState2FeaturesExt = 1000377000, [NativeName("Name", "VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX")] diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/VideoCapabilitiesFlagsKHR.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/VideoCapabilitiesFlagsKHR.gen.cs deleted file mode 100644 index 112ce3d28b..0000000000 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/VideoCapabilitiesFlagsKHR.gen.cs +++ /dev/null @@ -1,21 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -using System; -using Silk.NET.Core.Attributes; - -#pragma warning disable 1591 - -namespace Silk.NET.Vulkan -{ - [Flags()] - [NativeName("Name", "VkVideoCapabilitiesFlagsKHR")] - public enum VideoCapabilitiesFlagsKHR : int - { - [NativeName("Name", "VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR")] - VideoCapabilitiesProtectedContentBitKhr = 1, - [NativeName("Name", "VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR")] - VideoCapabilitiesSeparateReferenceImagesBitKhr = 2, - } -} diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/VideoCapabilityFlagsKHR.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/VideoCapabilityFlagsKHR.gen.cs new file mode 100644 index 0000000000..d7cfe7a0dd --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/VideoCapabilityFlagsKHR.gen.cs @@ -0,0 +1,21 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [Flags()] + [NativeName("Name", "VkVideoCapabilityFlagsKHR")] + public enum VideoCapabilityFlagsKHR : int + { + [NativeName("Name", "VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR")] + VideoCapabilityProtectedContentBitKhr = 1, + [NativeName("Name", "VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR")] + VideoCapabilitySeparateReferenceImagesBitKhr = 2, + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/VideoDecodeH264FieldLayoutFlagsEXT.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/VideoDecodeH264FieldLayoutFlagsEXT.gen.cs deleted file mode 100644 index b4c4fa9ac3..0000000000 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/VideoDecodeH264FieldLayoutFlagsEXT.gen.cs +++ /dev/null @@ -1,23 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -using System; -using Silk.NET.Core.Attributes; - -#pragma warning disable 1591 - -namespace Silk.NET.Vulkan -{ - [Flags()] - [NativeName("Name", "VkVideoDecodeH264FieldLayoutFlagsEXT")] - public enum VideoDecodeH264FieldLayoutFlagsEXT : int - { - [NativeName("Name", "VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT")] - VideoDecodeH264ProgressivePicturesOnlyExt = 0, - [NativeName("Name", "VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT")] - VideoDecodeH264FieldLayoutLineInterlacedPlaneBitExt = 1, - [NativeName("Name", "VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT")] - VideoDecodeH264FieldLayoutSeparateInterlacedPlaneBitExt = 2, - } -} diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/VideoDecodeH264PictureLayoutFlagsEXT.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/VideoDecodeH264PictureLayoutFlagsEXT.gen.cs new file mode 100644 index 0000000000..cdc734ad11 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/VideoDecodeH264PictureLayoutFlagsEXT.gen.cs @@ -0,0 +1,23 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [Flags()] + [NativeName("Name", "VkVideoDecodeH264PictureLayoutFlagsEXT")] + public enum VideoDecodeH264PictureLayoutFlagsEXT : int + { + [NativeName("Name", "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT")] + VideoDecodeH264PictureLayoutProgressiveExt = 0, + [NativeName("Name", "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT")] + VideoDecodeH264PictureLayoutInterlacedInterleavedLinesBitExt = 1, + [NativeName("Name", "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT")] + VideoDecodeH264PictureLayoutInterlacedSeparatePlanesBitExt = 2, + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Enums/VideoEncodeH264CapabilitiesFlagsEXT.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Enums/VideoEncodeH264CapabilityFlagsEXT.gen.cs similarity index 94% rename from src/Vulkan/Silk.NET.Vulkan/Enums/VideoEncodeH264CapabilitiesFlagsEXT.gen.cs rename to src/Vulkan/Silk.NET.Vulkan/Enums/VideoEncodeH264CapabilityFlagsEXT.gen.cs index 9e92f28869..8f6d554d76 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Enums/VideoEncodeH264CapabilitiesFlagsEXT.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Enums/VideoEncodeH264CapabilityFlagsEXT.gen.cs @@ -10,8 +10,8 @@ namespace Silk.NET.Vulkan { [Flags()] - [NativeName("Name", "VkVideoEncodeH264CapabilitiesFlagsEXT")] - public enum VideoEncodeH264CapabilitiesFlagsEXT : int + [NativeName("Name", "VkVideoEncodeH264CapabilityFlagsEXT")] + public enum VideoEncodeH264CapabilityFlagsEXT : int { [NativeName("Name", "VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT")] VideoEncodeH264CapabilityCabacBitExt = 1, diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/MemoryGetRemoteAddressInfoNV.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/MemoryGetRemoteAddressInfoNV.gen.cs new file mode 100644 index 0000000000..766774d587 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/MemoryGetRemoteAddressInfoNV.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkMemoryGetRemoteAddressInfoNV")] + public unsafe partial struct MemoryGetRemoteAddressInfoNV + { + public MemoryGetRemoteAddressInfoNV + ( + StructureType? sType = StructureType.MemoryGetRemoteAddressInfoNV, + void* pNext = null, + DeviceMemory? memory = null, + ExternalMemoryHandleTypeFlags? handleType = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (memory is not null) + { + Memory = memory.Value; + } + + if (handleType is not null) + { + HandleType = handleType.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkDeviceMemory")] + [NativeName("Type.Name", "VkDeviceMemory")] + [NativeName("Name", "memory")] + public DeviceMemory Memory; +/// + [NativeName("Type", "VkExternalMemoryHandleTypeFlagBits")] + [NativeName("Type.Name", "VkExternalMemoryHandleTypeFlagBits")] + [NativeName("Name", "handleType")] + public ExternalMemoryHandleTypeFlags HandleType; + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceExternalMemoryRDMAFeaturesNV.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceExternalMemoryRDMAFeaturesNV.gen.cs new file mode 100644 index 0000000000..88cb7ace3f --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceExternalMemoryRDMAFeaturesNV.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV")] + public unsafe partial struct PhysicalDeviceExternalMemoryRDMAFeaturesNV + { + public PhysicalDeviceExternalMemoryRDMAFeaturesNV + ( + StructureType? sType = StructureType.PhysicalDeviceExternalMemoryRdmaFeaturesNV, + void* pNext = null, + Bool32? externalMemoryRdma = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (externalMemoryRdma is not null) + { + ExternalMemoryRdma = externalMemoryRdma.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "externalMemoryRDMA")] + public Bool32 ExternalMemoryRdma; + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceInvocationMaskFeaturesHUAWEI.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceInvocationMaskFeaturesHUAWEI.gen.cs new file mode 100644 index 0000000000..d76e32277b --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceInvocationMaskFeaturesHUAWEI.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI")] + public unsafe partial struct PhysicalDeviceInvocationMaskFeaturesHUAWEI + { + public PhysicalDeviceInvocationMaskFeaturesHUAWEI + ( + StructureType? sType = StructureType.PhysicalDeviceInvocationMaskFeaturesHuawei, + void* pNext = null, + Bool32? invocationMask = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (invocationMask is not null) + { + InvocationMask = invocationMask.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "invocationMask")] + public Bool32 InvocationMask; + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDevicePresentIdFeaturesKHR.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDevicePresentIdFeaturesKHR.gen.cs new file mode 100644 index 0000000000..7a313d2103 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDevicePresentIdFeaturesKHR.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDevicePresentIdFeaturesKHR")] + public unsafe partial struct PhysicalDevicePresentIdFeaturesKHR + { + public PhysicalDevicePresentIdFeaturesKHR + ( + StructureType? sType = StructureType.PhysicalDevicePresentIDFeaturesKhr, + void* pNext = null, + Bool32? presentId = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (presentId is not null) + { + PresentId = presentId.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "presentId")] + public Bool32 PresentId; + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDevicePresentWaitFeaturesKHR.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDevicePresentWaitFeaturesKHR.gen.cs new file mode 100644 index 0000000000..7c70bec94e --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDevicePresentWaitFeaturesKHR.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDevicePresentWaitFeaturesKHR")] + public unsafe partial struct PhysicalDevicePresentWaitFeaturesKHR + { + public PhysicalDevicePresentWaitFeaturesKHR + ( + StructureType? sType = StructureType.PhysicalDevicePresentWaitFeaturesKhr, + void* pNext = null, + Bool32? presentWait = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (presentWait is not null) + { + PresentWait = presentWait.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "presentWait")] + public Bool32 PresentWait; + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceShaderAtomicFloat2FeaturesEXT.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceShaderAtomicFloat2FeaturesEXT.gen.cs new file mode 100644 index 0000000000..e7edcb81ea --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PhysicalDeviceShaderAtomicFloat2FeaturesEXT.gen.cs @@ -0,0 +1,182 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT")] + public unsafe partial struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT + { + public PhysicalDeviceShaderAtomicFloat2FeaturesEXT + ( + StructureType? sType = StructureType.PhysicalDeviceShaderAtomicFloat2FeaturesExt, + void* pNext = null, + Bool32? shaderBufferFloat16Atomics = null, + Bool32? shaderBufferFloat16AtomicAdd = null, + Bool32? shaderBufferFloat16AtomicMinMax = null, + Bool32? shaderBufferFloat32AtomicMinMax = null, + Bool32? shaderBufferFloat64AtomicMinMax = null, + Bool32? shaderSharedFloat16Atomics = null, + Bool32? shaderSharedFloat16AtomicAdd = null, + Bool32? shaderSharedFloat16AtomicMinMax = null, + Bool32? shaderSharedFloat32AtomicMinMax = null, + Bool32? shaderSharedFloat64AtomicMinMax = null, + Bool32? shaderImageFloat32AtomicMinMax = null, + Bool32? sparseImageFloat32AtomicMinMax = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (shaderBufferFloat16Atomics is not null) + { + ShaderBufferFloat16Atomics = shaderBufferFloat16Atomics.Value; + } + + if (shaderBufferFloat16AtomicAdd is not null) + { + ShaderBufferFloat16AtomicAdd = shaderBufferFloat16AtomicAdd.Value; + } + + if (shaderBufferFloat16AtomicMinMax is not null) + { + ShaderBufferFloat16AtomicMinMax = shaderBufferFloat16AtomicMinMax.Value; + } + + if (shaderBufferFloat32AtomicMinMax is not null) + { + ShaderBufferFloat32AtomicMinMax = shaderBufferFloat32AtomicMinMax.Value; + } + + if (shaderBufferFloat64AtomicMinMax is not null) + { + ShaderBufferFloat64AtomicMinMax = shaderBufferFloat64AtomicMinMax.Value; + } + + if (shaderSharedFloat16Atomics is not null) + { + ShaderSharedFloat16Atomics = shaderSharedFloat16Atomics.Value; + } + + if (shaderSharedFloat16AtomicAdd is not null) + { + ShaderSharedFloat16AtomicAdd = shaderSharedFloat16AtomicAdd.Value; + } + + if (shaderSharedFloat16AtomicMinMax is not null) + { + ShaderSharedFloat16AtomicMinMax = shaderSharedFloat16AtomicMinMax.Value; + } + + if (shaderSharedFloat32AtomicMinMax is not null) + { + ShaderSharedFloat32AtomicMinMax = shaderSharedFloat32AtomicMinMax.Value; + } + + if (shaderSharedFloat64AtomicMinMax is not null) + { + ShaderSharedFloat64AtomicMinMax = shaderSharedFloat64AtomicMinMax.Value; + } + + if (shaderImageFloat32AtomicMinMax is not null) + { + ShaderImageFloat32AtomicMinMax = shaderImageFloat32AtomicMinMax.Value; + } + + if (sparseImageFloat32AtomicMinMax is not null) + { + SparseImageFloat32AtomicMinMax = sparseImageFloat32AtomicMinMax.Value; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "shaderBufferFloat16Atomics")] + public Bool32 ShaderBufferFloat16Atomics; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "shaderBufferFloat16AtomicAdd")] + public Bool32 ShaderBufferFloat16AtomicAdd; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "shaderBufferFloat16AtomicMinMax")] + public Bool32 ShaderBufferFloat16AtomicMinMax; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "shaderBufferFloat32AtomicMinMax")] + public Bool32 ShaderBufferFloat32AtomicMinMax; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "shaderBufferFloat64AtomicMinMax")] + public Bool32 ShaderBufferFloat64AtomicMinMax; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "shaderSharedFloat16Atomics")] + public Bool32 ShaderSharedFloat16Atomics; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "shaderSharedFloat16AtomicAdd")] + public Bool32 ShaderSharedFloat16AtomicAdd; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "shaderSharedFloat16AtomicMinMax")] + public Bool32 ShaderSharedFloat16AtomicMinMax; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "shaderSharedFloat32AtomicMinMax")] + public Bool32 ShaderSharedFloat32AtomicMinMax; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "shaderSharedFloat64AtomicMinMax")] + public Bool32 ShaderSharedFloat64AtomicMinMax; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "shaderImageFloat32AtomicMinMax")] + public Bool32 ShaderImageFloat32AtomicMinMax; +/// + [NativeName("Type", "VkBool32")] + [NativeName("Type.Name", "VkBool32")] + [NativeName("Name", "sparseImageFloat32AtomicMinMax")] + public Bool32 SparseImageFloat32AtomicMinMax; + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PipelineCacheHeaderVersionOne.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PipelineCacheHeaderVersionOne.gen.cs new file mode 100644 index 0000000000..b92dd96e92 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PipelineCacheHeaderVersionOne.gen.cs @@ -0,0 +1,77 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPipelineCacheHeaderVersionOne")] + public unsafe partial struct PipelineCacheHeaderVersionOne + { + public PipelineCacheHeaderVersionOne + ( + uint? headerSize = null, + PipelineCacheHeaderVersion? headerVersion = null, + uint? vendorID = null, + uint? deviceID = null + ) : this() + { + if (headerSize is not null) + { + HeaderSize = headerSize.Value; + } + + if (headerVersion is not null) + { + HeaderVersion = headerVersion.Value; + } + + if (vendorID is not null) + { + VendorID = vendorID.Value; + } + + if (deviceID is not null) + { + DeviceID = deviceID.Value; + } + } + +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "headerSize")] + public uint HeaderSize; +/// + [NativeName("Type", "VkPipelineCacheHeaderVersion")] + [NativeName("Type.Name", "VkPipelineCacheHeaderVersion")] + [NativeName("Name", "headerVersion")] + public PipelineCacheHeaderVersion HeaderVersion; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "vendorID")] + public uint VendorID; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "deviceID")] + public uint DeviceID; + /// + [NativeName("Type", "uint8_t")] + [NativeName("Type.Name", "uint8_t")] + [NativeName("Name", "pipelineCacheUUID")] + public fixed byte PipelineCacheUuid[16]; + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/PresentIdKHR.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/PresentIdKHR.gen.cs new file mode 100644 index 0000000000..93930f6e55 --- /dev/null +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/PresentIdKHR.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Vulkan +{ + [NativeName("Name", "VkPresentIdKHR")] + public unsafe partial struct PresentIdKHR + { + public PresentIdKHR + ( + StructureType? sType = StructureType.PresentIDKhr, + void* pNext = null, + uint? swapchainCount = null, + ulong* pPresentIds = null + ) : this() + { + if (sType is not null) + { + SType = sType.Value; + } + + if (pNext is not null) + { + PNext = pNext; + } + + if (swapchainCount is not null) + { + SwapchainCount = swapchainCount.Value; + } + + if (pPresentIds is not null) + { + PPresentIds = pPresentIds; + } + } + +/// + [NativeName("Type", "VkStructureType")] + [NativeName("Type.Name", "VkStructureType")] + [NativeName("Name", "sType")] + public StructureType SType; +/// + [NativeName("Type", "void*")] + [NativeName("Type.Name", "void")] + [NativeName("Name", "pNext")] + public void* PNext; +/// + [NativeName("Type", "uint32_t")] + [NativeName("Type.Name", "uint32_t")] + [NativeName("Name", "swapchainCount")] + public uint SwapchainCount; +/// + [NativeName("Type", "uint64_t*")] + [NativeName("Type.Name", "uint64_t")] + [NativeName("Name", "pPresentIds")] + public ulong* PPresentIds; + } +} diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/VideoCapabilitiesKHR.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/VideoCapabilitiesKHR.gen.cs index a1fed086b3..18b4f48228 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Structs/VideoCapabilitiesKHR.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/VideoCapabilitiesKHR.gen.cs @@ -23,7 +23,7 @@ public VideoCapabilitiesKHR ( StructureType? sType = StructureType.VideoCapabilitiesKhr, void* pNext = null, - VideoCapabilitiesFlagsKHR? capabilityFlags = null, + VideoCapabilityFlagsKHR? capabilityFlags = null, ulong? minBitstreamBufferOffsetAlignment = null, ulong? minBitstreamBufferSizeAlignment = null, Extent2D? videoPictureExtentGranularity = null, @@ -95,10 +95,10 @@ public VideoCapabilitiesKHR [NativeName("Name", "pNext")] public void* PNext; /// - [NativeName("Type", "VkVideoCapabilitiesFlagsKHR")] - [NativeName("Type.Name", "VkVideoCapabilitiesFlagsKHR")] + [NativeName("Type", "VkVideoCapabilityFlagsKHR")] + [NativeName("Type.Name", "VkVideoCapabilityFlagsKHR")] [NativeName("Name", "capabilityFlags")] - public VideoCapabilitiesFlagsKHR CapabilityFlags; + public VideoCapabilityFlagsKHR CapabilityFlags; /// [NativeName("Type", "VkDeviceSize")] [NativeName("Type.Name", "VkDeviceSize")] diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/VideoDecodeH264ProfileEXT.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/VideoDecodeH264ProfileEXT.gen.cs index ece284ac5b..9951b87fcf 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Structs/VideoDecodeH264ProfileEXT.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/VideoDecodeH264ProfileEXT.gen.cs @@ -24,7 +24,7 @@ public VideoDecodeH264ProfileEXT StructureType? sType = StructureType.VideoDecodeH264ProfileExt, void* pNext = null, Video.StdVideoH264ProfileIdc? stdProfileIdc = null, - VideoDecodeH264FieldLayoutFlagsEXT? fieldLayout = null + VideoDecodeH264PictureLayoutFlagsEXT? pictureLayout = null ) : this() { if (sType is not null) @@ -42,9 +42,9 @@ public VideoDecodeH264ProfileEXT StdProfileIdc = stdProfileIdc.Value; } - if (fieldLayout is not null) + if (pictureLayout is not null) { - FieldLayout = fieldLayout.Value; + PictureLayout = pictureLayout.Value; } } @@ -64,9 +64,9 @@ public VideoDecodeH264ProfileEXT [NativeName("Name", "stdProfileIdc")] public Video.StdVideoH264ProfileIdc StdProfileIdc; /// - [NativeName("Type", "VkVideoDecodeH264FieldLayoutFlagsEXT")] - [NativeName("Type.Name", "VkVideoDecodeH264FieldLayoutFlagsEXT")] - [NativeName("Name", "fieldLayout")] - public VideoDecodeH264FieldLayoutFlagsEXT FieldLayout; + [NativeName("Type", "VkVideoDecodeH264PictureLayoutFlagsEXT")] + [NativeName("Type.Name", "VkVideoDecodeH264PictureLayoutFlagsEXT")] + [NativeName("Name", "pictureLayout")] + public VideoDecodeH264PictureLayoutFlagsEXT PictureLayout; } } diff --git a/src/Vulkan/Silk.NET.Vulkan/Structs/VideoEncodeH264CapabilitiesEXT.gen.cs b/src/Vulkan/Silk.NET.Vulkan/Structs/VideoEncodeH264CapabilitiesEXT.gen.cs index 23da045643..33038d0288 100644 --- a/src/Vulkan/Silk.NET.Vulkan/Structs/VideoEncodeH264CapabilitiesEXT.gen.cs +++ b/src/Vulkan/Silk.NET.Vulkan/Structs/VideoEncodeH264CapabilitiesEXT.gen.cs @@ -23,7 +23,7 @@ public VideoEncodeH264CapabilitiesEXT ( StructureType? sType = StructureType.VideoEncodeH264CapabilitiesExt, void* pNext = null, - VideoEncodeH264CapabilitiesFlagsEXT? flags = null, + VideoEncodeH264CapabilityFlagsEXT? flags = null, VideoEncodeH264InputModeFlagsEXT? inputModeFlags = null, VideoEncodeH264OutputModeFlagsEXT? outputModeFlags = null, Extent2D? minPictureSizeInMbs = null, @@ -113,10 +113,10 @@ public VideoEncodeH264CapabilitiesEXT [NativeName("Name", "pNext")] public void* PNext; /// - [NativeName("Type", "VkVideoEncodeH264CapabilitiesFlagsEXT")] - [NativeName("Type.Name", "VkVideoEncodeH264CapabilitiesFlagsEXT")] + [NativeName("Type", "VkVideoEncodeH264CapabilityFlagsEXT")] + [NativeName("Type.Name", "VkVideoEncodeH264CapabilityFlagsEXT")] [NativeName("Name", "flags")] - public VideoEncodeH264CapabilitiesFlagsEXT Flags; + public VideoEncodeH264CapabilityFlagsEXT Flags; /// [NativeName("Type", "VkVideoEncodeH264InputModeFlagsEXT")] [NativeName("Type.Name", "VkVideoEncodeH264InputModeFlagsEXT")] From 5796e0b2db8fdb45b310344b175547d5fb142e26 Mon Sep 17 00:00:00 2001 From: Dylan Perks Date: Sun, 8 Aug 2021 00:31:06 +0100 Subject: [PATCH 2/2] Add missing projects, thanks validation checks --- Silk.NET.sln | 40 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) diff --git a/Silk.NET.sln b/Silk.NET.sln index 62eeb1a459..565f9416ed 100644 --- a/Silk.NET.sln +++ b/Silk.NET.sln @@ -1,4 +1,4 @@ - + Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 16 VisualStudioVersion = 16.0.30517.126 @@ -444,6 +444,16 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.Vulkan.Extensions. EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.Vulkan.Extensions.FB", "src\Vulkan\Extensions\Silk.NET.Vulkan.Extensions.FB\Silk.NET.Vulkan.Extensions.FB.csproj", "{D1DD841D-9F34-47A6-91EB-A8632D577BD7}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{16AFCF73-8CC1-4B5D-8969-A90F468DC6D5}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "OpenXR", "OpenXR", "{1E76124C-D849-4D44-B7A2-5383C8C636B9}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Extensions", "Extensions", "{048B85BE-276B-4C75-B4FF-BB825C0FEE54}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.OpenXR.Extensions.UNITY", "src\OpenXR\Extensions\Silk.NET.OpenXR.Extensions.UNITY\Silk.NET.OpenXR.Extensions.UNITY.csproj", "{AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.OpenXR.Extensions.LIV", "src\OpenXR\Extensions\Silk.NET.OpenXR.Extensions.LIV\Silk.NET.OpenXR.Extensions.LIV.csproj", "{0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -2661,6 +2671,30 @@ Global {D1DD841D-9F34-47A6-91EB-A8632D577BD7}.Release|x64.Build.0 = Release|Any CPU {D1DD841D-9F34-47A6-91EB-A8632D577BD7}.Release|x86.ActiveCfg = Release|Any CPU {D1DD841D-9F34-47A6-91EB-A8632D577BD7}.Release|x86.Build.0 = Release|Any CPU + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}.Debug|x64.ActiveCfg = Debug|Any CPU + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}.Debug|x64.Build.0 = Debug|Any CPU + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}.Debug|x86.ActiveCfg = Debug|Any CPU + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}.Debug|x86.Build.0 = Debug|Any CPU + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}.Release|Any CPU.Build.0 = Release|Any CPU + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}.Release|x64.ActiveCfg = Release|Any CPU + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}.Release|x64.Build.0 = Release|Any CPU + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}.Release|x86.ActiveCfg = Release|Any CPU + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5}.Release|x86.Build.0 = Release|Any CPU + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}.Debug|x64.ActiveCfg = Debug|Any CPU + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}.Debug|x64.Build.0 = Debug|Any CPU + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}.Debug|x86.ActiveCfg = Debug|Any CPU + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}.Debug|x86.Build.0 = Debug|Any CPU + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}.Release|Any CPU.Build.0 = Release|Any CPU + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}.Release|x64.ActiveCfg = Release|Any CPU + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}.Release|x64.Build.0 = Release|Any CPU + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}.Release|x86.ActiveCfg = Release|Any CPU + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -2864,6 +2898,10 @@ Global {AB59F09A-9BD9-4CBB-8497-87B768C7C949} = {49BC383A-D7E6-4013-93C7-371479B984CC} {23172004-FF6B-45D8-9653-944CECE741E1} = {757F2B10-B69D-4C19-BFE0-D99070A00AD9} {D1DD841D-9F34-47A6-91EB-A8632D577BD7} = {49BC383A-D7E6-4013-93C7-371479B984CC} + {1E76124C-D849-4D44-B7A2-5383C8C636B9} = {16AFCF73-8CC1-4B5D-8969-A90F468DC6D5} + {048B85BE-276B-4C75-B4FF-BB825C0FEE54} = {1E76124C-D849-4D44-B7A2-5383C8C636B9} + {AE5A7BBD-E303-46C4-9DDC-29E80C9128F5} = {048B85BE-276B-4C75-B4FF-BB825C0FEE54} + {0D1E5AD9-E329-4B84-A5FE-FC1EE33BF038} = {048B85BE-276B-4C75-B4FF-BB825C0FEE54} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {F5273D7F-3334-48DF-94E3-41AE6816CD4D}