Allow getting pointer (address) to Numba's int/float variables

Feature Request

---

For example I have some cffi or ctypes function that has a pointer int64_t * as one of its argument. I need to call this function passing pointer (address) of single-value np.int64 variable. I found a way how to get and pass a pointer to any element of Numpy array, using .ctypes property. But didn’t find any way of passing a pointer to int64 (np.int64 or numba.int64). Example code:

import numba, numpy as np

@numba.njit(cache = True)
def f():
    a = np.zeros((10,), dtype = np.int64)
    aptr = a[1:3].ctypes
    b = np.int64
    bptr = b.ctypes
    c = numba.int64
    cptr = c.ctypes
    
f()

In code above Numpy array has .ctypes property, returning aptr that can be easily passed as cffi function’s int64_t * argument. But single-value variables b and c don’t have same .ctypes property to get pointer of type int64_t * (compile error Unknown attribute 'ctypes' of type class(int64)). Neither I found any special function to get such pointer.

Maybe such address-getting special function exists somewhere in Numba’s library, can anyone point me please to such function? Otherwise it would be nice to implement such.

As a workaround I was creating single-element Numpy array, copying int value into this element and then passing arr[0:1].ctypes to function. After function completes I copy value from array back to single-value variable. But this workaround is very inefficient especially if to create array every time.

[gmarkall]

I think it will be difficult in general in Numba to support taking the address of variables, because we don’t have a well-defined concept of storage classes for variables in the frontend of Numba, unlike in C - so we’d need to do a lot of work to catch edge cases where a variable might not necessarily have any storage allocated.

@gmarkall Can you give an example, where you expect issues, with the code from above? Isn’t cgutils.alloca_once_value() a lightweight workaround (allocating stack memory, copying the provided value to this allocated stack-memory and returning a pointer to that stack memory), or do I get something wrong here?

I don’t expect issues with this. My concern was around more general support for taking the address of variables, where you do something like:

x = 2
addr = get_address_of(x)  # addr = &x
c_function(addr)          # Does *addr = 3
print(x)                  # prints 3

[max9111]

@polkovnikov

I don’t see a reason why the following code should not work for (i8/i16/i32/i64/f32/f64) , but I haven’t tested it thoroughly.

from numba import types
from numba.extending import intrinsic
from numba.core import cgutils

@intrinsic
def val_to_ptr(typingctx, data):
    def impl(context, builder, signature, args):
        ptr = cgutils.alloca_once_value(builder,args[0])
        return ptr
    sig = types.CPointer(nb.typeof(data).instance_type)(nb.typeof(data).instance_type)
    return sig, impl

@intrinsic
def ptr_to_val(typingctx, data):
    def impl(context, builder, signature, args):
        val = builder.load(args[0])
        return val
    sig = data.dtype(types.CPointer(data.dtype))
    return sig, impl

Example

@nb.cfunc(types.void(nb.types.CPointer(nb.types.double)))
def add(x):
    wrapped_arr=nb.carray(x,shape=(1))
    wrapped_arr[0]+=1

@nb.njit()
def Test(A):
    x=val_to_ptr(A)
    add(x)
    y=ptr_to_val(x)
    return y

Test(15.)
#16.0