How to correctly manage memory during ccall?

General Usage
,
3

Memory management in C++ is indeed a bit of a pain as compared to a language like Julia; and it gets even more complex when trying to merge the two together. :slight_smile:

First things first: let’s build up a good mental model for memory ownership. Either the memory will be owned by Julia, which means Julia will allocate the memory, pass it as a pointer to C++ code, then will later free it, or the memory will be owned by the C++ code, which means the C++ code will allocate it, pass it back to Julia, and later Julia will request it to be freed by passing it back to the C++ code to explicitly free it. As it stands, your code is doing neither of these things. :wink:

Let’s start at the end and work our way backwards. You have a resultStruct * that you’re returning. Now, a pointer is something that “points” to a memory address, so the first thing we should do is look to see where you are setting what the pointer points to. In this case, you’re not setting it at all, so when you do something like returnvalue->x = res_x.data(), the returnvalue->x means:

  • dereference returnvalue
  • go to the x slot offset within a resultStruct
  • set its value to the return value of res_x.data()

If you’ve never initialized the value of returnvalue, this means that you’re zooming off to a random memory address. This may or may not segfault. If it doesn’t segfault, it means that returnvalue is being randomly initialized with a memory address that is mapped into your program, but it can be overwritten by some other piece of code at any time.

You need to explicitly allocate memory for this object by calling either malloc() or new. Example:

struct resultStruct* returnvalue = (resultStruct*) malloc(sizeof(resultStruct));

This will allocate a chunk of memory and store the result into returnvalue; so that issue is gone. Next, let’s look at what we’re feeding into returnvalue: when you call res_x.data(), you’re getting a pointer to an internal buffer of a vector<double>, but when that vector<double> falls out of scope, its memory will become invalid; it is freed and can be overwritten at any time. You need to take ownership of those pieces as well.

The easiest way is to allocate memory for these pieces as well:

returnvalue->x = (double*) malloc(sizeof(double)*len);
returnvalue->y = (double*) malloc(sizeof(double)*len);
returnvalue->id = (int*) malloc(sizeof(int)*len);

Then copy the values over:

memcpy(returnvalue->x, res_x.data(), sizeof(double)*len);
memcpy(returnvalue->y, res_y.data(), sizeof(double)*len);
memcpy(returnvalue->id, res_id.data(), sizeof(int)*len);

Alright, now let’s switch over to the Julia side. We want to receive an object of type resultStruct *, which will be easiest if we have a resultStruct on the Julia side. I see your ccall() signature says Ptr{Tuple{Ptr{Float64},Ptr{Float64},Ptr{Int},Int}}, which I don’t think will work. (It might, but I’ve just never seen that before). I suggest mirroring the C struct in Julia-land with gross Ptr objects and whatnot, then having a Julia structure that can be constructed off of one of those C struct analogues:

# Exact same structure as on the C++ side; keep this in-sync with your C++ code.
struct CResultStruct
    x::Ptr{Cdouble}
    y::Ptr{Cdouble}
    id::Ptr{Cint}
    len::Cint
end

# Nice, Julia-side structure with Vectors and whatnot
struct JuliaResultStruct
    x::Vector{Cdouble}
    y::Vector{Cdouble}
    id::Vector{Cint}
end

# Function to take a pointer to a C `resultStruct` and turn it into a Julia `resultStruct`
function JuliaResultStruct(c_ptr::Ptr{CResultStruct})
    # This gives us a CResultStruct
    res = unsafe_load(c_ptr)
    return JuliaResultStruct(
        # Wrap around the C structure's `x` memory, turning it into a `Vector`
        unsafe_wrap(Vector{Cdouble}, res.x, (res.len,)),
        unsafe_wrap(Vector{Cdouble}, res.y, (res.len,)),
        unsafe_wrap(Vector{Cint}, res.id, (res.len,)),
    )
end

Then, your ccall() expects back a Ptr{CResultStruct}, and you just call JuliaResultStruct(result) to get back stuff that Julia can deal with.

Once you’re done with that chunk of data, you need to free it, so once you are certain that all Julia objects referring to the arrays are gone, you would pass the Ptr{CResultStruct} to another C++ function that calls free() on res->x, res->y, res->id and finally res itself.

10 Likes