Ideas For Function Pointer Types

[BCSharp]

The current convention in code is that to store pointers to unmanaged functions, IntPtr is used. To call such an unmanaged function, a delegate is created and invoked. Example (from IC_bytes_buffer_getbuffer):

delegate int PyBuffer_FillInfoDelegate(IntPtr view, IntPtr obj, IntPtr buf, nint len, int @readonly, int flags);
...
var del = Marshal.GetDelegateForFunctionPointer<PyBuffer_FillInfoDelegate>(PyBuffer_FillInfo);
return del(view, self, data, length, 1, flags);

This is not very efficient, and since C# 9 we have function pointers:

unsafe
{
    var funcp = (delegate* unmanaged[Cdecl]<IntPtr, IntPtr, IntPtr, nint, int, int, int>)PyBuffer_FillInfo;
    return funcp(view, self, data, length, 1, flags);
}

Note: Cdecl is required for NETFRAMEWORK, and not required for NET, I think. On .NET, the framework should be able to determine the OS-default calling convention at runtime. This may incur some runtime cost, but the code is portable between OSes. Since the unmanaged DLL is not portable anyway, there is probably no good reason not to make the managed DLL OS-specific as well.

Also, using IntPtr is not type-safe, since no signature checking is done or even possible. Ironically, safer code (in the literal sense) requires an unsafe block. Ideally, a CPython API function would be already be declared as a function pointer with a proper signature in PythonApi.Generated.cs. Instead of:

public IntPtr PyBuffer_FillInfo
{
    get
    {
        IntPtr address;
        if (this.data.TryGetValue("PyBuffer_FillInfo", out address))
        {
            return address;
        }
        return IntPtr.Zero;
    }
}

we could have

public delegate* unmanaged[Cdecl]<IntPtr, IntPtr, IntPtr, nint, int, int, int> PyBuffer_FillInfo
    => this.data.TryGetValue("PyBuffer_FillInfo", out IntPtr address) ? address.ToPointer() : null;

Then the API call could be:

unsafe
{
    return PyBuffer_FillInfo(view, self, data, length, 1, flags);
}

This could introduce a number of unsafe code blocks, but the code will be actually safer, and not to forget, faster too. However, declaring classes PythonApi and PythonMapper as unsafe makes a lot of sense and will reduce the number of unsafe blocks or methods in the code.

The only place where IntPtr storing a function pointer will still be needed is if the value needs to be boxed.

The disadvantage of this proposal is that it is not possible to give a function pointer type a name (unlike in C, where typedef can be used). I think in practice this should not be a big hardship, as most (if not all) definitions of actual values are in the generated code, and in some other places, perhaps var could be used.

[slozier]

I think PyBuffer_FillInfo is the only one of these that we have (so far), but the way I did it (calling GetDelegateForFunctionPointer every time) is definitely not great. Although I have other functions in mind that I would like to call so some codegen would probably be helpful...

Maybe we could go one step further and hide away the unsafe aspect by wrapping it:

namespace PythonApi {
    public int PyBuffer_FillInfo(IntPtr arg0, IntPtr arg1, IntPtr arg2, nint arg3, int arg4, int arg5) {
        unsafe {
            return UnmanagedFunctions.PyBuffer_FillInfo(arg0, arg1, arg2, arg3, arg4, arg5);
        }
    }
}