Ccall with a C struct containing a pointer

[Sukera]

@luke-kiernan

In that case, do things look different than in the above examples?

Not really - the difference is just that you wouldn’t pass a Ptr/Ref in the ccall but just the struct directly, without the need for pointer_from_objref and the like at all.

@luke-kiernan

The structs mostly line up, but there’s small differences: 0- vs 1-indexing, Cints vs Clongs for row indices.

If the size/type of the individual items in the struct is different, you’ll want/need to make sure to convert the data to that type. So from julian Int64 to a Cint, by storing the data in a new bit of memory.

@luke-kiernan

For a more minimal, less involved example: take a look at DenseMatrix. This only has a single pointer, and no re-indexing is required. How would I write cconvert so as to take a Julia A::Matrix{T} and create a B::DenseMatrix{T} such that B.data = pointer(A.ref)

That should be something like

function Base.cconvert(::Type{DenseMatrix{T}}, m::Matrix{T}) where T
    rowCount, colCount = size(m)
    stride = 1 # not 100% sure on this - check that row/column majorness aligns! Julia is column major!
    dm = DenseMatrix{T}(rowCount, colCount, strig, #= the attribute type object =#, C_NULL)
    return (m, dm)
end

function Base.unsafe_convert(::Type{DenseMatrix{T}}, tup::Tuple{Matrix{T}, DenseMatrix{T}}) where T
    m, dm = tup
    dm.data = pointer(m) # m is GC-preserved in this function, so this is safe
    dm
end

@luke-kiernan

I’m nesting structs (SparseMatrixStructure inside SparseMatrix), where the inner struct is not an isbits struct type. Thus the Illegal instruction error: fields weren’t lining up.

Yes, the types you end up passing to C must match exactly in terms of layout. You can check Base.allocated_inline, which should help with that. The important thing is that the outermost struct you pass is mutable (either because the struct itself is mutable, or it’s a Ref, which is just a mutable struct with a single field), so that any modification C makes into that memory is visible again on the julia side. To Julia this would be “as if” the entire content was replaced, even though C just performed a partial write.