Allocate Graph memory from Ruby GC

Previously, the Graph objects were initialized in a new Rust-allocated Box.

Let's switch to allocating this memory from the Ruby GC. This has several benefits:
1. Like `xmalloc()`, it gives the GC a chance to run if there isn't much free memory available
2. It puts us on the path to using `RUBY_TYPED_EMBEDDABLE` for more optimal allocations

Author: amomchilov

ext/rubydex/graph.c

@@ -38,10 +38,14 @@ static const char *extract_self_receiver(VALUE opts) {
     return StringValueCStr(kwarg_val);
 }
 
-// Free function for the custom Graph allocator. We always have to call into Rust to free data allocated by it
+// Free function for the custom Graph allocator.
 static void graph_free(void *ptr) {
     if (ptr) {
-        rdx_graph_free(ptr);
+        // let the Rust side drop the Graph struct internally.
+        rdx_graph_drop(ptr);
+
+        // Free the TypeData Ruby object itself
+        xfree(ptr);
     }
 }
 
@@ -61,8 +65,13 @@ const rb_data_type_t graph_type = {
 // Custom allocator for the Graph class. Calls into Rust to create a new `Arc<Mutex<Graph>>` that gets stored internally
 // as a void pointer
 static VALUE rdxr_graph_alloc(VALUE klass) {
-    void *graph = rdx_graph_new();
-    return TypedData_Wrap_Struct(klass, &graph_type, graph);
+    void *graph;
+    // Can't use `TypedData_Make_Struct`, because the Graph is a Rust type that isn't exposed directly to C.
+    VALUE graph_obj = rb_data_typed_object_make(klass, &graph_type, &graph, RDX_GRAPH_SIZE);
+
+    rdx_graph_init(graph);
+
+    return graph_obj;
 }
 
 // Graph#index_all: (Array[String] file_paths) -> Array[String]

ext/rubydex/handle.h

@@ -35,14 +35,15 @@ static const rb_data_type_t handle_type = {
 };
 
 static VALUE rdxr_handle_alloc(VALUE klass) {
-    HandleData *data = ALLOC(HandleData);
+    HandleData *data;
+    VALUE handle_obj = TypedData_Make_Struct(klass, HandleData, &handle_type, data);
 
     *data = (HandleData) {
         .graph_obj = Qnil,
         .id = 0,
     };
 
-    return TypedData_Wrap_Struct(klass, &handle_type, data);
+    return handle_obj;
 }
 
 static VALUE rdxr_handle_initialize(VALUE self, VALUE graph_obj, VALUE id_val) {

rust/rubydex-sys/src/graph_api.rs

@@ -23,38 +23,48 @@ use std::{mem, ptr};
 
 pub type GraphPointer = *mut c_void;
 
-/// Creates a new graph within a mutex. This is meant to be used when creating new Graph objects in Ruby
+/// Returns the number of bytes needed to store a Graph in externally allocated memory.
 #[unsafe(no_mangle)]
-pub extern "C" fn rdx_graph_new() -> GraphPointer {
-    Box::into_raw(Box::new(Graph::new())) as GraphPointer
+pub static RDX_GRAPH_SIZE: usize = mem::size_of::<Graph>();
+
+/// Initializes a Graph in-place at the given `pointer`.
+///
+/// # Safety
+///
+/// `pointer` must point to valid, properly aligned memory of at least `RDX_GRAPH_SIZE` bytes.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_init(pointer: GraphPointer) {
+    unsafe {
+        pointer.cast::<Graph>().write(Graph::new());
+    }
 }
 
-/// Frees a Graph through its pointer
+/// Drops a Graph initialized by `rdx_graph_init` without freeing the underlying memory.
+///
+/// # Safety
+///
+/// `pointer` must point to a valid initialized Graph.
 #[unsafe(no_mangle)]
-pub extern "C" fn rdx_graph_free(pointer: GraphPointer) {
+pub unsafe extern "C" fn rdx_graph_drop(pointer: GraphPointer) {
     unsafe {
-        let _ = Box::from_raw(pointer.cast::<Graph>());
+        ptr::drop_in_place(pointer.cast::<Graph>());
     }
 }
 
 pub fn with_graph<F, T>(pointer: GraphPointer, action: F) -> T
 where
     F: FnOnce(&Graph) -> T,
 {
-    let mut graph = unsafe { Box::from_raw(pointer.cast::<Graph>()) };
-    let result = action(&mut graph);
-    mem::forget(graph);
-    result
+    let graph = unsafe { &*pointer.cast::<Graph>() };
+    action(graph)
 }
 
 fn with_mut_graph<F, T>(pointer: GraphPointer, action: F) -> T
 where
     F: FnOnce(&mut Graph) -> T,
 {
-    let mut graph = unsafe { Box::from_raw(pointer.cast::<Graph>()) };
-    let result = action(&mut graph);
-    mem::forget(graph);
-    result
+    let graph = unsafe { &mut *pointer.cast::<Graph>() };
+    action(graph)
 }
 
 /// Searches the graph using exact substring matching