public unsafe partial int EnqueueGenerateMipmap([Flow(FlowDirection.In)] nint command_queue, [Flow(FlowDirection.In)] nint src_image, [Flow(FlowDirection.In)] nint dst_image, [Flow(FlowDirection.In)] IMG mipmap_filter_mode, [Flow(FlowDirection.In)] nuint *array_region, [Flow(FlowDirection.In)] nuint *mip_region, [Flow(FlowDirection.In)] uint num_events_in_wait_list, [Flow(FlowDirection.In)] in nint event_wait_list, [Flow(FlowDirection.Out)] nint * @event);
public static extern int CoGetContextToken([NativeTypeName("ULONG_PTR *")] nuint *pToken);
public unsafe partial int GetKernelSubGroupInfo <T0>([Flow(FlowDirection.In)] nint in_kernel, [Flow(FlowDirection.In)] nint in_device, [Flow(FlowDirection.In)] uint param_name, [Flow(FlowDirection.In)] nuint input_value_size, [Flow(FlowDirection.In)] void *input_value, [Flow(FlowDirection.In)] nuint param_value_size, [Flow(FlowDirection.Out)] out T0 param_value, [Flow(FlowDirection.Out)] nuint *param_value_size_ret) where T0 : unmanaged;
public static extern HRESULT RegisterScaleChangeEvent(HANDLE hEvent, [NativeTypeName("DWORD_PTR *")] nuint *pdwCookie);
public int get_hPal([NativeTypeName("HHANDLE *")] nuint *phPal)
{
return(((delegate * unmanaged <IPicture2 *, nuint *, int>)(lpVtbl[4]))((IPicture2 *)Unsafe.AsPointer(ref this), phPal));
}
public HRESULT AdviseTime([NativeTypeName("REFERENCE_TIME")] long baseTime, [NativeTypeName("REFERENCE_TIME")] long streamTime, HEVENT hEvent, [NativeTypeName("DWORD_PTR *")] nuint *pdwAdviseCookie)
{
return(((delegate * unmanaged <IReferenceClock2 *, long, long, HEVENT, nuint *, int>)(lpVtbl[4]))((IReferenceClock2 *)Unsafe.AsPointer(ref this), baseTime, streamTime, hEvent, pdwAdviseCookie));
}
public int OpenUnbufferedFileHandle(IUnbufferedFileHandleOplockCallback *oplockBreakCallback, [NativeTypeName("DWORD_PTR *")] nuint *fileHandle)
{
return(((delegate * unmanaged <IUnbufferedFileHandleProvider *, IUnbufferedFileHandleOplockCallback *, nuint *, int>)(lpVtbl[3]))((IUnbufferedFileHandleProvider *)Unsafe.AsPointer(ref this), oplockBreakCallback, fileHandle));
}
/*! ZDICT_trainFromBuffer():
* Train a dictionary from an array of samples.
* Redirect towards ZDICT_optimizeTrainFromBuffer_fastCover() single-threaded, with d=8, steps=4,
* f=20, and accel=1.
* Samples must be stored concatenated in a single flat buffer `samplesBuffer`,
* supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order.
* The resulting dictionary will be saved into `dictBuffer`.
* @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
* or an error code, which can be tested with ZDICT_isError().
* Note: Dictionary training will fail if there are not enough samples to construct a
* dictionary, or if most of the samples are too small (< 8 bytes being the lower limit).
* If dictionary training fails, you should use zstd without a dictionary, as the dictionary
* would've been ineffective anyways. If you believe your samples would benefit from a dictionary
* please open an issue with details, and we can look into it.
* Note: ZDICT_trainFromBuffer()'s memory usage is about 6 MB.
* Tips: In general, a reasonable dictionary has a size of ~ 100 KB.
* It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`.
* In general, it's recommended to provide a few thousands samples, though this can vary a lot.
* It's recommended that total size of all samples be about ~x100 times the target size of dictionary.
*/
public static nuint ZDICT_trainFromBuffer(void *dictBuffer, nuint dictBufferCapacity, void *samplesBuffer, nuint *samplesSizes, uint nbSamples)
{
ZDICT_fastCover_params_t @params;
memset((void *)&@params, 0, (nuint)(sizeof(ZDICT_fastCover_params_t)));
@params.d = 8;
@params.steps = 4;
@params.zParams.compressionLevel = 3;
return(ZDICT_optimizeTrainFromBuffer_fastCover(dictBuffer, dictBufferCapacity, samplesBuffer, samplesSizes, nbSamples, &@params));
}
public static nuint ZDICT_addEntropyTablesFromBuffer(void *dictBuffer, nuint dictContentSize, nuint dictBufferCapacity, void *samplesBuffer, nuint *samplesSizes, uint nbSamples)
{
ZDICT_params_t @params;
memset((void *)&@params, 0, (nuint)(sizeof(ZDICT_params_t)));
return(ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, dictBufferCapacity, samplesBuffer, samplesSizes, nbSamples, @params));
}
/*! ZDICT_finalizeDictionary():
* Given a custom content as a basis for dictionary, and a set of samples,
* finalize dictionary by adding headers and statistics according to the zstd
* dictionary format.
*
* Samples must be stored concatenated in a flat buffer `samplesBuffer`,
* supplied with an array of sizes `samplesSizes`, providing the size of each
* sample in order. The samples are used to construct the statistics, so they
* should be representative of what you will compress with this dictionary.
*
* The compression level can be set in `parameters`. You should pass the
* compression level you expect to use in production. The statistics for each
* compression level differ, so tuning the dictionary for the compression level
* can help quite a bit.
*
* You can set an explicit dictionary ID in `parameters`, or allow us to pick
* a random dictionary ID for you, but we can't guarantee no collisions.
*
* The dstDictBuffer and the dictContent may overlap, and the content will be
* appended to the end of the header. If the header + the content doesn't fit in
* maxDictSize the beginning of the content is truncated to make room, since it
* is presumed that the most profitable content is at the end of the dictionary,
* since that is the cheapest to reference.
*
* `dictContentSize` must be >= ZDICT_CONTENTSIZE_MIN bytes.
* `maxDictSize` must be >= max(dictContentSize, ZSTD_DICTSIZE_MIN).
*
* @return: size of dictionary stored into `dstDictBuffer` (<= `maxDictSize`),
* or an error code, which can be tested by ZDICT_isError().
* Note: ZDICT_finalizeDictionary() will push notifications into stderr if
* instructed to, using notificationLevel>0.
* NOTE: This function currently may fail in several edge cases including:
* * Not enough samples
* * Samples are uncompressible
* * Samples are all exactly the same
*/
public static nuint ZDICT_finalizeDictionary(void *dictBuffer, nuint dictBufferCapacity, void *customDictContent, nuint dictContentSize, void *samplesBuffer, nuint *samplesSizes, uint nbSamples, ZDICT_params_t @params)
{
nuint hSize;
byte *header = stackalloc byte[256];
int compressionLevel = (@params.compressionLevel == 0) ? 3 : @params.compressionLevel;
uint notificationLevel = @params.notificationLevel;
if (dictBufferCapacity < dictContentSize)
{
return(unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)));
}
if (dictContentSize < 128)
{
return(unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong)));
}
if (dictBufferCapacity < 256)
{
return(unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)));
}
MEM_writeLE32((void *)header, 0xEC30A437);
{
ulong randomID = XXH64(customDictContent, dictContentSize, 0);
uint compliantID = (uint)((randomID % ((1U << 31) - 32768)) + 32768);
uint dictID = @params.dictID != 0 ? @params.dictID : compliantID;
MEM_writeLE32((void *)(header + 4), dictID);
}
hSize = 8;
{
nuint eSize = ZDICT_analyzeEntropy((void *)(header + hSize), 256 - hSize, compressionLevel, samplesBuffer, samplesSizes, nbSamples, customDictContent, dictContentSize, notificationLevel);
if ((ZDICT_isError(eSize)) != 0)
{
return(eSize);
}
hSize += eSize;
}
if (hSize + dictContentSize > dictBufferCapacity)
{
dictContentSize = dictBufferCapacity - hSize;
}
{
nuint dictSize = hSize + dictContentSize;
sbyte *dictEnd = (sbyte *)(dictBuffer) + dictSize;
memmove((void *)(dictEnd - dictContentSize), customDictContent, dictContentSize);
memcpy(dictBuffer, (void *)header, hSize);
return(dictSize);
}
}
private static nuint ZDICT_addEntropyTablesFromBuffer_advanced(void *dictBuffer, nuint dictContentSize, nuint dictBufferCapacity, void *samplesBuffer, nuint *samplesSizes, uint nbSamples, ZDICT_params_t @params)
{
int compressionLevel = (@params.compressionLevel == 0) ? 3 : @params.compressionLevel;
uint notificationLevel = @params.notificationLevel;
nuint hSize = 8;
{
nuint eSize = ZDICT_analyzeEntropy((void *)((sbyte *)(dictBuffer) + hSize), dictBufferCapacity - hSize, compressionLevel, samplesBuffer, samplesSizes, nbSamples, (void *)((sbyte *)(dictBuffer) + dictBufferCapacity - dictContentSize), dictContentSize, notificationLevel);
if ((ZDICT_isError(eSize)) != 0)
{
return(eSize);
}
hSize += eSize;
}
MEM_writeLE32(dictBuffer, 0xEC30A437);
{
ulong randomID = XXH64((void *)((sbyte *)(dictBuffer) + dictBufferCapacity - dictContentSize), dictContentSize, 0);
uint compliantID = (uint)((randomID % ((1U << 31) - 32768)) + 32768);
uint dictID = @params.dictID != 0 ? @params.dictID : compliantID;
MEM_writeLE32((void *)((sbyte *)(dictBuffer) + 4), dictID);
}
if (hSize + dictContentSize < dictBufferCapacity)
{
memmove((void *)((sbyte *)(dictBuffer) + hSize), (void *)((sbyte *)(dictBuffer) + dictBufferCapacity - dictContentSize), dictContentSize);
}
return((dictBufferCapacity) < (hSize + dictContentSize) ? (dictBufferCapacity) : (hSize + dictContentSize));
}
private static nuint ZDICT_analyzeEntropy(void *dstBuffer, nuint maxDstSize, int compressionLevel, void *srcBuffer, nuint *fileSizes, uint nbFiles, void *dictBuffer, nuint dictBufferSize, uint notificationLevel)
{
uint * countLit = stackalloc uint[256];
HUF_CElt_s * hufTable = stackalloc HUF_CElt_s[256];
uint * offcodeCount = stackalloc uint[31];
short * offcodeNCount = stackalloc short[31];
uint offcodeMax = ZSTD_highbit32((uint)(dictBufferSize + (uint)(128 * (1 << 10))));
uint * matchLengthCount = stackalloc uint[53];
short * matchLengthNCount = stackalloc short[53];
uint * litLengthCount = stackalloc uint[36];
short * litLengthNCount = stackalloc short[36];
uint * repOffset = stackalloc uint[1024];
offsetCount_t *bestRepOffset = stackalloc offsetCount_t[4];
EStats_ress_t esr = new EStats_ress_t
{
dict = null,
zc = null,
workPlace = null,
};
ZSTD_parameters @params;
uint u, huffLog = 11, Offlog = 8, mlLog = 9, llLog = 9, total;
nuint pos = 0, errorCode;
nuint eSize = 0;
nuint totalSrcSize = ZDICT_totalSampleSize(fileSizes, nbFiles);
nuint averageSampleSize = totalSrcSize / (nbFiles + (uint)(nbFiles == 0 ? 1 : 0));
byte * dstPtr = (byte *)(dstBuffer);
if (offcodeMax > 30)
{
eSize = (unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dictionaryCreation_failed)));
goto _cleanup;
}
for (u = 0; u < 256; u++)
{
countLit[u] = 1;
}
for (u = 0; u <= offcodeMax; u++)
{
offcodeCount[u] = 1;
}
for (u = 0; u <= 52; u++)
{
matchLengthCount[u] = 1;
}
for (u = 0; u <= 35; u++)
{
litLengthCount[u] = 1;
}
memset((void *)repOffset, 0, (nuint)(sizeof(uint) * 1024));
repOffset[1] = repOffset[4] = repOffset[8] = 1;
memset((void *)bestRepOffset, 0, (nuint)(sizeof(offsetCount_t) * 4));
if (compressionLevel == 0)
{
compressionLevel = 3;
}
@params = ZSTD_getParams(compressionLevel, (ulong)averageSampleSize, dictBufferSize);
esr.dict = ZSTD_createCDict_advanced(dictBuffer, dictBufferSize, ZSTD_dictLoadMethod_e.ZSTD_dlm_byRef, ZSTD_dictContentType_e.ZSTD_dct_rawContent, @params.cParams, ZSTD_defaultCMem);
esr.zc = ZSTD_createCCtx();
esr.workPlace = malloc((nuint)((1 << 17)));
if (esr.dict == null || esr.zc == null || esr.workPlace == null)
{
eSize = (unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_memory_allocation)));
goto _cleanup;
}
for (u = 0; u < nbFiles; u++)
{
ZDICT_countEStats(esr, &@params, (uint *)countLit, (uint *)offcodeCount, (uint *)matchLengthCount, (uint *)litLengthCount, (uint *)repOffset, (void *)((sbyte *)(srcBuffer) + pos), fileSizes[u], notificationLevel);
pos += fileSizes[u];
}
{
nuint maxNbBits = HUF_buildCTable((HUF_CElt_s *)hufTable, (uint *)countLit, 255, huffLog);
if ((ERR_isError(maxNbBits)) != 0)
{
eSize = maxNbBits;
goto _cleanup;
}
if (maxNbBits == 8)
{
ZDICT_flatLit((uint *)countLit);
maxNbBits = HUF_buildCTable((HUF_CElt_s *)hufTable, (uint *)countLit, 255, huffLog);
assert(maxNbBits == 9);
}
huffLog = (uint)(maxNbBits);
}
{
uint offset;
for (offset = 1; offset < 1024; offset++)
{
ZDICT_insertSortCount(bestRepOffset, offset, repOffset[offset]);
}
}
total = 0;
for (u = 0; u <= offcodeMax; u++)
{
total += offcodeCount[u];
}
errorCode = FSE_normalizeCount((short *)offcodeNCount, Offlog, (uint *)offcodeCount, total, offcodeMax, 1);
if ((ERR_isError(errorCode)) != 0)
{
eSize = errorCode;
goto _cleanup;
}
Offlog = (uint)(errorCode);
total = 0;
for (u = 0; u <= 52; u++)
{
total += matchLengthCount[u];
}
errorCode = FSE_normalizeCount((short *)matchLengthNCount, mlLog, (uint *)matchLengthCount, total, 52, 1);
if ((ERR_isError(errorCode)) != 0)
{
eSize = errorCode;
goto _cleanup;
}
mlLog = (uint)(errorCode);
total = 0;
for (u = 0; u <= 35; u++)
{
total += litLengthCount[u];
}
errorCode = FSE_normalizeCount((short *)litLengthNCount, llLog, (uint *)litLengthCount, total, 35, 1);
if ((ERR_isError(errorCode)) != 0)
{
eSize = errorCode;
goto _cleanup;
}
llLog = (uint)(errorCode);
{
nuint hhSize = HUF_writeCTable((void *)dstPtr, maxDstSize, (HUF_CElt_s *)hufTable, 255, huffLog);
if ((ERR_isError(hhSize)) != 0)
{
eSize = hhSize;
goto _cleanup;
}
dstPtr += hhSize;
maxDstSize -= hhSize;
eSize += hhSize;
}
{
nuint ohSize = FSE_writeNCount((void *)dstPtr, maxDstSize, (short *)offcodeNCount, 30, Offlog);
if ((ERR_isError(ohSize)) != 0)
{
eSize = ohSize;
goto _cleanup;
}
dstPtr += ohSize;
maxDstSize -= ohSize;
eSize += ohSize;
}
{
nuint mhSize = FSE_writeNCount((void *)dstPtr, maxDstSize, (short *)matchLengthNCount, 52, mlLog);
if ((ERR_isError(mhSize)) != 0)
{
eSize = mhSize;
goto _cleanup;
}
dstPtr += mhSize;
maxDstSize -= mhSize;
eSize += mhSize;
}
{
nuint lhSize = FSE_writeNCount((void *)dstPtr, maxDstSize, (short *)litLengthNCount, 35, llLog);
if ((ERR_isError(lhSize)) != 0)
{
eSize = lhSize;
goto _cleanup;
}
dstPtr += lhSize;
maxDstSize -= lhSize;
eSize += lhSize;
}
if (maxDstSize < 12)
{
eSize = (unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall)));
goto _cleanup;
}
MEM_writeLE32((void *)(dstPtr + 0), repStartValue[0]);
MEM_writeLE32((void *)(dstPtr + 4), repStartValue[1]);
MEM_writeLE32((void *)(dstPtr + 8), repStartValue[2]);
eSize += 12;
_cleanup:
ZSTD_freeCDict(esr.dict);
ZSTD_freeCCtx(esr.zc);
free(esr.workPlace);
return(eSize);
}
public HRESULT ProgressAdvise(IDiscMasterProgressEvents *pEvents, [NativeTypeName("UINT_PTR *")] nuint *pvCookie)
{
return(((delegate * unmanaged <IDiscMaster *, IDiscMasterProgressEvents *, nuint *, int>)(lpVtbl[11]))((IDiscMaster *)Unsafe.AsPointer(ref this), pEvents, pvCookie));
}
public unsafe partial int GetKernelSuggestedLocalWorkSize([Flow(FlowDirection.In)] nint command_queue, [Flow(FlowDirection.In)] nint kernel, [Flow(FlowDirection.In)] uint work_dim, [Flow(FlowDirection.In)] nuint *global_work_offset, [Flow(FlowDirection.In)] in nuint global_work_size, [Flow(FlowDirection.Out)] nuint *suggested_local_work_size);
// [Verify (PlatformInvoke)] static extern unsafe void *NewBase64Decode(sbyte *inputBuffer, nuint length, nuint *outputLength);
public static unsafe int GetLayerInfo <T0>(this LoaderLayers thisApi, [Flow(FlowDirection.In)] nuint param_value_size, [Flow(FlowDirection.In)] uint param_name, [Flow(FlowDirection.Out)] Span <T0> param_value, [Flow(FlowDirection.Out)] nuint *param_value_size_ret) where T0 : unmanaged
{
// SpanOverloader
return(thisApi.GetLayerInfo(param_value_size, param_name, out param_value.GetPinnableReference(), param_value_size_ret));
}
// [Verify (PlatformInvoke)] // [return: NullAllowed] static extern unsafe sbyte *NewBase64Encode(void *inputBuffer, nuint length, bool separateLines, nuint *outputLength);
// Try to atomically claim a sequence of `count` bits in a single
// field at `idx` in `bitmap`. Returns `true` on success.
private static bool mi_bitmap_try_find_claim_field([NativeTypeName("mi_bitmap_t")] nuint *bitmap, [NativeTypeName("size_t")] nuint idx, [NativeTypeName("const size_t")] nuint count, [NativeTypeName("mi_bitmap_index_t*")] out nuint bitmap_idx)
{
nuint *field = &bitmap[idx];
nuint map = mi_atomic_load_relaxed(ref *field);
if (map == MI_BITMAP_FIELD_FULL)
{
// short cut
bitmap_idx = 0;
return(false);
}
// search for 0-bit sequence of length count
nuint mask = mi_bitmap_mask_(count, 0);
nuint bitidx_max = MI_BITMAP_FIELD_BITS - count;
// quickly find the first zero bit if possible
nuint bitidx = mi_bsf(~map);
// invariant: m == mask shifted by bitidx
nuint m = mask << (int)bitidx;
// scan linearly for a free range of zero bits
while (bitidx <= bitidx_max)
{
if ((map & m) == 0)
{
// are the mask bits free at bitidx?
// no overflow?
mi_assert_internal((MI_DEBUG > 1) && ((m >> (int)bitidx) == mask));
nuint newmap = map | m;
mi_assert_internal((MI_DEBUG > 1) && (((newmap ^ map) >> (int)bitidx) == mask));
if (!mi_atomic_cas_weak_acq_rel(ref *field, ref map, newmap))
{
// TODO: use strong cas here?
// no success, another thread claimed concurrently.. keep going (with updated `map`)
continue;
}
else
{
// success, we claimed the bits!
bitmap_idx = mi_bitmap_index_create(idx, bitidx);
return(true);
}
}
else
{
// on to the next bit range
nuint shift = (count == 1) ? 1 : (mi_bsr(map & m) - bitidx + 1);
mi_assert_internal((MI_DEBUG > 1) && (shift > 0) && (shift <= count));
bitidx += shift;
m <<= (int)shift;
}
}
// no bits found
bitmap_idx = 0;
return(false);
}
public HRESULT AdvisePeriodic([NativeTypeName("REFERENCE_TIME")] long startTime, [NativeTypeName("REFERENCE_TIME")] long periodTime, HSEMAPHORE hSemaphore, [NativeTypeName("DWORD_PTR *")] nuint *pdwAdviseCookie)
{
return(((delegate * unmanaged <IReferenceClock2 *, long, long, HSEMAPHORE, nuint *, int>)(lpVtbl[5]))((IReferenceClock2 *)Unsafe.AsPointer(ref this), startTime, periodTime, hSemaphore, pdwAdviseCookie));
}
private static bool mi_bitmap_is_claimed([NativeTypeName("mi_bitmap_t")] nuint *bitmap, [NativeTypeName("size_t")] nuint bitmap_fields, [NativeTypeName("size_t")] nuint count, [NativeTypeName("mi_bitmap_index_t")] nuint bitmap_idx)
=> mi_bitmap_is_claimedx(bitmap, bitmap_fields, count, bitmap_idx, out _);
public void GetTypeName([NativeTypeName("LPSTR")] sbyte *pTypeName, [NativeTypeName("SIZE_T *")] nuint *pBufferLength)
{
((delegate * stdcall <ID3D11ClassInstance *, sbyte *, nuint *, void>)(lpVtbl[10]))((ID3D11ClassInstance *)Unsafe.AsPointer(ref this), pTypeName, pBufferLength);
}
private static bool mi_bitmap_is_any_claimed([NativeTypeName("mi_bitmap_t")] nuint *bitmap, [NativeTypeName("size_t")] nuint bitmap_fields, [NativeTypeName("size_t")] nuint count, [NativeTypeName("mi_bitmap_index_t")] nuint bitmap_idx)
{
_ = mi_bitmap_is_claimedx(bitmap, bitmap_fields, count, bitmap_idx, out bool any_ones);
return(any_ones);
}
/// <summary>To be documented.</summary>
public static unsafe Result GetValidationCacheData <T0>(this ExtValidationCache thisApi, [Count(Count = 0)] Device device, [Count(Count = 0)] ValidationCacheEXT validationCache, [Count(Count = 0)] nuint *pDataSize, [Count(Parameter = "pDataSize")] Span <T0> pData) where T0 : unmanaged
{
// SpanOverloader
return(thisApi.GetValidationCacheData(device, validationCache, pDataSize, ref pData.GetPinnableReference()));
}
public unsafe partial int GetLayerInfo([Flow(FlowDirection.In)] nuint param_value_size, [Flow(FlowDirection.In)] uint param_name, [Flow(FlowDirection.Out)] void *param_value, [Flow(FlowDirection.Out)] nuint *param_value_size_ret);
public int SelectPicture([NativeTypeName("HDC")] IntPtr hDCIn, [NativeTypeName("HDC *")] IntPtr *phDCOut, [NativeTypeName("HHANDLE *")] nuint *phBmpOut)
{
return(((delegate * unmanaged <IPicture2 *, IntPtr, IntPtr *, nuint *, int>)(lpVtbl[11]))((IPicture2 *)Unsafe.AsPointer(ref this), hDCIn, phDCOut, phBmpOut));
}
public unsafe partial int GetLayerInfo <T0>([Flow(FlowDirection.In)] nuint param_value_size, [Flow(FlowDirection.In)] uint param_name, [Flow(FlowDirection.Out)] out T0 param_value, [Flow(FlowDirection.Out)] nuint *param_value_size_ret) where T0 : unmanaged;
public unsafe partial int GetKernelSubGroupInfo([Flow(FlowDirection.In)] nint in_kernel, [Flow(FlowDirection.In)] nint in_device, [Flow(FlowDirection.In)] uint param_name, [Flow(FlowDirection.In)] nuint input_value_size, [Flow(FlowDirection.In)] void *input_value, [Flow(FlowDirection.In)] nuint param_value_size, [Flow(FlowDirection.Out)] void *param_value, [Flow(FlowDirection.Out)] nuint *param_value_size_ret);
public int Query([NativeTypeName("IUnknown *")] IUnknown *pPrx, RPCOPT_PROPERTIES dwProperty, [NativeTypeName("ULONG_PTR *")] nuint *pdwValue)
{
return(((delegate * unmanaged <IRpcOptions *, IUnknown *, RPCOPT_PROPERTIES, nuint *, int>)(lpVtbl[4]))((IRpcOptions *)Unsafe.AsPointer(ref this), pPrx, dwProperty, pdwValue));
}
public static unsafe void BindBuffersRange(this ArbMultiBind thisApi, [Flow(FlowDirection.In)] BufferTargetARB target, [Flow(FlowDirection.In)] uint first, [Flow(FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(FlowDirection.In)] ReadOnlySpan <uint> buffers, [Count(Parameter = "count"), Flow(FlowDirection.In)] nint *offsets, [Count(Parameter = "count"), Flow(FlowDirection.In)] nuint *sizes)
{
// SpanOverloader
thisApi.BindBuffersRange(target, first, count, in buffers.GetPinnableReference(), offsets, sizes);
}
public static partial void mi_process_info([NativeTypeName("size_t*")] nuint *elapsed_msecs, [NativeTypeName("size_t*")] nuint *user_msecs, [NativeTypeName("size_t*")] nuint *system_msecs, [NativeTypeName("size_t*")] nuint *current_rss, [NativeTypeName("size_t*")] nuint *peak_rss, [NativeTypeName("size_t*")] nuint *current_commit, [NativeTypeName("size_t*")] nuint *peak_commit, [NativeTypeName("size_t*")] nuint *page_faults);
