Skip to content

Migrate DllImport P/Invokes to LibraryImport #162

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
craig-b wants to merge 5 commits into
base: main
Choose a base branch
from
Open

Migrate DllImport P/Invokes to LibraryImport #162

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
2d14dd6
Migrate TensorSharp.Core P/Invokes to LibraryImport
craig-b Aug 15, 2026
af405e7
Migrate GGML backend P/Invokes to LibraryImport
craig-b Aug 15, 2026
754ec24
Migrate MLX backend P/Invokes to LibraryImport
craig-b Aug 15, 2026
0c2ff16
Migrate CUDA interop P/Invokes to LibraryImport
craig-b Aug 15, 2026
d3e9c11
Migrate remaining libc P/Invokes to LibraryImport
craig-b Aug 15, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 5 additions & 3 deletions InferenceWeb.Tests/Qwen35TokenDecodeContractTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -167,10 +167,12 @@ public void DecodePInvoke_MatchesPublicManagedParameterContract(
publicMethod.GetParameters().Select(parameter => parameter.ParameterType),
nativeMethod.GetParameters().Select(parameter => parameter.ParameterType));

DllImportAttribute import = nativeMethod.GetCustomAttribute<DllImportAttribute>()!;
LibraryImportAttribute import = nativeMethod.GetCustomAttribute<LibraryImportAttribute>()!;
Assert.NotNull(import);
Assert.Equal("GgmlOps", import.Value);
Assert.Equal(CallingConvention.Cdecl, import.CallingConvention);
Assert.Equal("GgmlOps", import.LibraryName);
UnmanagedCallConvAttribute callConv = nativeMethod.GetCustomAttribute<UnmanagedCallConvAttribute>()!;
Assert.NotNull(callConv);
Assert.Contains(typeof(System.Runtime.CompilerServices.CallConvCdecl), callConv.CallConvs!);
Assert.Equal(nativeMethodName, nativeMethod.Name);

ParameterInfo reseedParameter = nativeMethod.GetParameters()[2];
Expand Down
30 changes: 15 additions & 15 deletions TensorSharp.Backends.Cuda/Interop/CublasApi.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,24 +3,24 @@

namespace TensorSharp.Cuda.Interop
{
internal static class CublasApi
internal static partial class CublasApi
{
private const string LibName = "cublas";

[DllImport(LibName, EntryPoint = "cublasCreate_v2")]
public static extern int cublasCreate(out IntPtr handle);
[LibraryImport(LibName, EntryPoint = "cublasCreate_v2")]
public static partial int cublasCreate(out IntPtr handle);

[DllImport(LibName, EntryPoint = "cublasDestroy_v2")]
public static extern int cublasDestroy(IntPtr handle);
[LibraryImport(LibName, EntryPoint = "cublasDestroy_v2")]
public static partial int cublasDestroy(IntPtr handle);

[DllImport(LibName, EntryPoint = "cublasSetStream_v2")]
public static extern int cublasSetStream(IntPtr handle, IntPtr stream);
[LibraryImport(LibName, EntryPoint = "cublasSetStream_v2")]
public static partial int cublasSetStream(IntPtr handle, IntPtr stream);

[DllImport(LibName)]
public static extern int cublasSetMathMode(IntPtr handle, int mode);
[LibraryImport(LibName)]
public static partial int cublasSetMathMode(IntPtr handle, int mode);

[DllImport(LibName, EntryPoint = "cublasSgemm_v2")]
public static extern int cublasSgemm(
[LibraryImport(LibName, EntryPoint = "cublasSgemm_v2")]
public static partial int cublasSgemm(
IntPtr handle,
int transa,
int transb,
Expand All @@ -36,8 +36,8 @@ public static extern int cublasSgemm(
IntPtr c,
int ldc);

[DllImport(LibName)]
public static extern int cublasSgemmStridedBatched(
[LibraryImport(LibName)]
public static partial int cublasSgemmStridedBatched(
IntPtr handle,
int transa,
int transb,
Expand All @@ -57,8 +57,8 @@ public static extern int cublasSgemmStridedBatched(
long strideC,
int batchCount);

[DllImport(LibName)]
public static extern int cublasGemmEx(
[LibraryImport(LibName)]
public static partial int cublasGemmEx(
IntPtr handle,
int transa,
int transb,
Expand Down
194 changes: 97 additions & 97 deletions TensorSharp.Backends.Cuda/Interop/CudaDriverApi.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,107 +3,107 @@

namespace TensorSharp.Cuda.Interop
{
internal static class CudaDriverApi
internal static partial class CudaDriverApi
{
private const string LibName = "cuda";

[DllImport(LibName)]
public static extern int cuInit(uint flags);
[LibraryImport(LibName)]
public static partial int cuInit(uint flags);

[DllImport(LibName)]
public static extern int cuDeviceGet(out int device, int ordinal);
[LibraryImport(LibName)]
public static partial int cuDeviceGet(out int device, int ordinal);

[DllImport(LibName)]
public static extern int cuDeviceGetCount(out int count);
[LibraryImport(LibName)]
public static partial int cuDeviceGetCount(out int count);

[DllImport(LibName)]
public static extern int cuDeviceGetName(byte[] name, int len, int device);
[LibraryImport(LibName)]
public static partial int cuDeviceGetName(byte[] name, int len, int device);

[DllImport(LibName, EntryPoint = "cuDeviceTotalMem_v2")]
public static extern int cuDeviceTotalMem(out UIntPtr bytes, int device);
[LibraryImport(LibName, EntryPoint = "cuDeviceTotalMem_v2")]
public static partial int cuDeviceTotalMem(out UIntPtr bytes, int device);

[DllImport(LibName, EntryPoint = "cuMemGetInfo_v2")]
public static extern int cuMemGetInfo(out UIntPtr free, out UIntPtr total);
[LibraryImport(LibName, EntryPoint = "cuMemGetInfo_v2")]
public static partial int cuMemGetInfo(out UIntPtr free, out UIntPtr total);

[DllImport(LibName)]
public static extern int cuDeviceGetAttribute(out int value, int attribute, int device);
[LibraryImport(LibName)]
public static partial int cuDeviceGetAttribute(out int value, int attribute, int device);

[DllImport(LibName, EntryPoint = "cuCtxCreate_v2")]
public static extern int cuCtxCreate(out IntPtr ctx, uint flags, int device);
[LibraryImport(LibName, EntryPoint = "cuCtxCreate_v2")]
public static partial int cuCtxCreate(out IntPtr ctx, uint flags, int device);

[DllImport(LibName, EntryPoint = "cuCtxDestroy_v2")]
public static extern int cuCtxDestroy(IntPtr ctx);
[LibraryImport(LibName, EntryPoint = "cuCtxDestroy_v2")]
public static partial int cuCtxDestroy(IntPtr ctx);

[DllImport(LibName)]
public static extern int cuCtxSetCurrent(IntPtr ctx);
[LibraryImport(LibName)]
public static partial int cuCtxSetCurrent(IntPtr ctx);

[DllImport(LibName)]
public static extern int cuCtxGetCurrent(out IntPtr ctx);
[LibraryImport(LibName)]
public static partial int cuCtxGetCurrent(out IntPtr ctx);

[DllImport(LibName)]
public static extern int cuDevicePrimaryCtxRetain(out IntPtr ctx, int device);
[LibraryImport(LibName)]
public static partial int cuDevicePrimaryCtxRetain(out IntPtr ctx, int device);

[DllImport(LibName)]
public static extern int cuDevicePrimaryCtxRelease(int device);
[LibraryImport(LibName)]
public static partial int cuDevicePrimaryCtxRelease(int device);

[DllImport(LibName, EntryPoint = "cuMemAlloc_v2")]
public static extern int cuMemAlloc(out IntPtr devicePtr, UIntPtr byteSize);
[LibraryImport(LibName, EntryPoint = "cuMemAlloc_v2")]
public static partial int cuMemAlloc(out IntPtr devicePtr, UIntPtr byteSize);

[DllImport(LibName, EntryPoint = "cuMemFree_v2")]
public static extern int cuMemFree(IntPtr devicePtr);
[LibraryImport(LibName, EntryPoint = "cuMemFree_v2")]
public static partial int cuMemFree(IntPtr devicePtr);

/// <summary>Page-locked (pinned) host allocation. A captured HtoD memcpy
/// node whose source is pinned host memory re-reads the buffer on every
/// graph launch, which is how decode-graph replays receive per-token
/// parameters (see CudaDecodeDynParams).</summary>
[DllImport(LibName, EntryPoint = "cuMemHostAlloc")]
public static extern int cuMemHostAlloc(out IntPtr hostPtr, UIntPtr byteSize, uint flags);
[LibraryImport(LibName, EntryPoint = "cuMemHostAlloc")]
public static partial int cuMemHostAlloc(out IntPtr hostPtr, UIntPtr byteSize, uint flags);

[DllImport(LibName, EntryPoint = "cuMemFreeHost")]
public static extern int cuMemFreeHost(IntPtr hostPtr);
[LibraryImport(LibName, EntryPoint = "cuMemFreeHost")]
public static partial int cuMemFreeHost(IntPtr hostPtr);

[DllImport(LibName, EntryPoint = "cuMemcpyHtoD_v2")]
public static extern int cuMemcpyHtoD(IntPtr dstDevice, IntPtr srcHost, UIntPtr byteCount);
[LibraryImport(LibName, EntryPoint = "cuMemcpyHtoD_v2")]
public static partial int cuMemcpyHtoD(IntPtr dstDevice, IntPtr srcHost, UIntPtr byteCount);

[DllImport(LibName, EntryPoint = "cuMemcpyHtoDAsync_v2")]
public static extern int cuMemcpyHtoDAsync(IntPtr dstDevice, IntPtr srcHost, UIntPtr byteCount, IntPtr stream);
[LibraryImport(LibName, EntryPoint = "cuMemcpyHtoDAsync_v2")]
public static partial int cuMemcpyHtoDAsync(IntPtr dstDevice, IntPtr srcHost, UIntPtr byteCount, IntPtr stream);

[DllImport(LibName, EntryPoint = "cuMemcpyDtoH_v2")]
public static extern int cuMemcpyDtoH(IntPtr dstHost, IntPtr srcDevice, UIntPtr byteCount);
[LibraryImport(LibName, EntryPoint = "cuMemcpyDtoH_v2")]
public static partial int cuMemcpyDtoH(IntPtr dstHost, IntPtr srcDevice, UIntPtr byteCount);

[DllImport(LibName, EntryPoint = "cuMemcpyDtoHAsync_v2")]
public static extern int cuMemcpyDtoHAsync(IntPtr dstHost, IntPtr srcDevice, UIntPtr byteCount, IntPtr stream);
[LibraryImport(LibName, EntryPoint = "cuMemcpyDtoHAsync_v2")]
public static partial int cuMemcpyDtoHAsync(IntPtr dstHost, IntPtr srcDevice, UIntPtr byteCount, IntPtr stream);

[DllImport(LibName, EntryPoint = "cuMemcpyDtoD_v2")]
public static extern int cuMemcpyDtoD(IntPtr dstDevice, IntPtr srcDevice, UIntPtr byteCount);
[LibraryImport(LibName, EntryPoint = "cuMemcpyDtoD_v2")]
public static partial int cuMemcpyDtoD(IntPtr dstDevice, IntPtr srcDevice, UIntPtr byteCount);

[DllImport(LibName, EntryPoint = "cuMemcpyDtoDAsync_v2")]
public static extern int cuMemcpyDtoDAsync(IntPtr dstDevice, IntPtr srcDevice, UIntPtr byteCount, IntPtr stream);
[LibraryImport(LibName, EntryPoint = "cuMemcpyDtoDAsync_v2")]
public static partial int cuMemcpyDtoDAsync(IntPtr dstDevice, IntPtr srcDevice, UIntPtr byteCount, IntPtr stream);

[DllImport(LibName, EntryPoint = "cuMemsetD8_v2")]
public static extern int cuMemsetD8(IntPtr dstDevice, byte value, UIntPtr count);
[LibraryImport(LibName, EntryPoint = "cuMemsetD8_v2")]
public static partial int cuMemsetD8(IntPtr dstDevice, byte value, UIntPtr count);

[DllImport(LibName, EntryPoint = "cuMemsetD8Async")]
public static extern int cuMemsetD8Async(IntPtr dstDevice, byte value, UIntPtr count, IntPtr stream);
[LibraryImport(LibName, EntryPoint = "cuMemsetD8Async")]
public static partial int cuMemsetD8Async(IntPtr dstDevice, byte value, UIntPtr count, IntPtr stream);

[DllImport(LibName)]
public static extern int cuModuleLoadData(out IntPtr module, IntPtr image);
[LibraryImport(LibName)]
public static partial int cuModuleLoadData(out IntPtr module, IntPtr image);

[DllImport(LibName)]
public static extern int cuModuleGetFunction(out IntPtr function, IntPtr module, string name);
[LibraryImport(LibName, StringMarshalling = StringMarshalling.Utf8)]
public static partial int cuModuleGetFunction(out IntPtr function, IntPtr module, string name);

[DllImport(LibName)]
public static extern int cuModuleUnload(IntPtr module);
[LibraryImport(LibName)]
public static partial int cuModuleUnload(IntPtr module);

[DllImport(LibName)]
public static extern int cuFuncSetAttribute(IntPtr function, int attribute, int value);
[LibraryImport(LibName)]
public static partial int cuFuncSetAttribute(IntPtr function, int attribute, int value);

// CUfunction_attribute: opt-in cap for dynamic shared memory per block
// (default launches are limited to 48 KB without it).
public const int CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES = 8;

[DllImport(LibName)]
public static extern int cuLaunchKernel(
[LibraryImport(LibName)]
public static partial int cuLaunchKernel(
IntPtr function,
uint gridDimX,
uint gridDimY,
Expand All @@ -116,33 +116,33 @@ public static extern int cuLaunchKernel(
IntPtr kernelParams,
IntPtr extra);

[DllImport(LibName)]
public static extern int cuStreamCreate(out IntPtr stream, uint flags);
[LibraryImport(LibName)]
public static partial int cuStreamCreate(out IntPtr stream, uint flags);

[DllImport(LibName, EntryPoint = "cuStreamDestroy_v2")]
public static extern int cuStreamDestroy(IntPtr stream);
[LibraryImport(LibName, EntryPoint = "cuStreamDestroy_v2")]
public static partial int cuStreamDestroy(IntPtr stream);

[DllImport(LibName)]
public static extern int cuStreamSynchronize(IntPtr stream);
[LibraryImport(LibName)]
public static partial int cuStreamSynchronize(IntPtr stream);

// ---- CUDA Graphs (stream capture) ----
[DllImport(LibName, EntryPoint = "cuStreamBeginCapture_v2")]
public static extern int cuStreamBeginCapture(IntPtr stream, int mode);
[LibraryImport(LibName, EntryPoint = "cuStreamBeginCapture_v2")]
public static partial int cuStreamBeginCapture(IntPtr stream, int mode);

[DllImport(LibName)]
public static extern int cuStreamEndCapture(IntPtr stream, out IntPtr graph);
[LibraryImport(LibName)]
public static partial int cuStreamEndCapture(IntPtr stream, out IntPtr graph);

[DllImport(LibName)]
public static extern int cuGraphInstantiateWithFlags(out IntPtr graphExec, IntPtr graph, ulong flags);
[LibraryImport(LibName)]
public static partial int cuGraphInstantiateWithFlags(out IntPtr graphExec, IntPtr graph, ulong flags);

[DllImport(LibName)]
public static extern int cuGraphLaunch(IntPtr graphExec, IntPtr stream);
[LibraryImport(LibName)]
public static partial int cuGraphLaunch(IntPtr graphExec, IntPtr stream);

[DllImport(LibName)]
public static extern int cuGraphExecDestroy(IntPtr graphExec);
[LibraryImport(LibName)]
public static partial int cuGraphExecDestroy(IntPtr graphExec);

[DllImport(LibName)]
public static extern int cuGraphDestroy(IntPtr graph);
[LibraryImport(LibName)]
public static partial int cuGraphDestroy(IntPtr graph);

// CUstreamCaptureMode: 0 = GLOBAL, 1 = THREAD_LOCAL, 2 = RELAXED.
public const int CU_STREAM_CAPTURE_MODE_THREAD_LOCAL = 1;
Expand All @@ -151,34 +151,34 @@ public static extern int cuLaunchKernel(
// responsibility for the referenced memory's lifetime.
public const int CU_STREAM_CAPTURE_MODE_RELAXED = 2;

[DllImport(LibName)]
public static extern int cuGetErrorString(int error, out IntPtr str);
[LibraryImport(LibName)]
public static partial int cuGetErrorString(int error, out IntPtr str);

// ---- CUDA Events ----
[DllImport(LibName)]
public static extern int cuEventCreate(out IntPtr phEvent, uint flags);
[LibraryImport(LibName)]
public static partial int cuEventCreate(out IntPtr phEvent, uint flags);

[DllImport(LibName, EntryPoint = "cuEventDestroy_v2")]
public static extern int cuEventDestroy(IntPtr hEvent);
[LibraryImport(LibName, EntryPoint = "cuEventDestroy_v2")]
public static partial int cuEventDestroy(IntPtr hEvent);

[DllImport(LibName, EntryPoint = "cuEventRecord")]
public static extern int cuEventRecord(IntPtr hEvent, IntPtr hStream);
[LibraryImport(LibName, EntryPoint = "cuEventRecord")]
public static partial int cuEventRecord(IntPtr hEvent, IntPtr hStream);

[DllImport(LibName)]
public static extern int cuEventSynchronize(IntPtr hEvent);
[LibraryImport(LibName)]
public static partial int cuEventSynchronize(IntPtr hEvent);

[DllImport(LibName)]
public static extern int cuStreamWaitEvent(IntPtr hStream, IntPtr hEvent, uint flags);
[LibraryImport(LibName)]
public static partial int cuStreamWaitEvent(IntPtr hStream, IntPtr hEvent, uint flags);

// ---- Peer-to-Peer (multi-GPU) ----
[DllImport(LibName)]
public static extern int cuDeviceCanAccessPeer(out int canAccessPeer, int dev, int peerDev);
[LibraryImport(LibName)]
public static partial int cuDeviceCanAccessPeer(out int canAccessPeer, int dev, int peerDev);

[DllImport(LibName)]
public static extern int cuCtxEnablePeerAccess(IntPtr peerContext, uint flags);
[LibraryImport(LibName)]
public static partial int cuCtxEnablePeerAccess(IntPtr peerContext, uint flags);

[DllImport(LibName)]
public static extern int cuMemcpyPeerAsync(
[LibraryImport(LibName)]
public static partial int cuMemcpyPeerAsync(
IntPtr dstDevice, IntPtr dstContext,
IntPtr srcDevice, IntPtr srcContext,
UIntPtr byteCount, IntPtr hStream);
Expand Down
Loading
Loading