I read on Paul Graham’s site an article in which Lisp programmer Carl de Marcken of ITA says:

Because we have about 2 gigs of static data we need rapid access to, we use C++ code to memory-map huge files containing pointerless C structs (of flights, fares, etc), and then access these from Common Lisp using foreign data accesses. A struct field access compiles into two or three instructions, so there’s not really any performance. penalty for accessing C rather than Lisp objects.

This has an application to some features I want to add to OCI*ML, so I whipped up a quick proof-of-concept in OCaml and C (with a few suggestions on SO, none of which I followed in the end!). First the C code:

#include <stdio.h> #include <string.h> #include <caml/mlvalues.h> #include <caml/alloc.h> #include <caml/memory.h> #include <caml/custom.h> typedef struct { void* ptr; } c_heap_t; #define C_heap_val(v) (*((c_heap_t*) Data_custom_val(v))) /* callback function to free memory, called by the OCaml GC */ void c_free_heap_t(value ch) { CAMLparam1(ch); c_heap_t x = C_heap_val(ch); free(x.ptr); CAMLreturn0; } /* associate callback with datatype */ static struct custom_operations c_heap_t_custom_ops = { "c_heap_t_custom_ops", &c_free_heap_t, NULL, NULL, NULL, NULL}; /* test struct */ typedef struct { int x; int y; int z; } triple_t; /* allocate a block of b bytes and wrap it in a c_heap_t struct */ value c_alloc_heap_memory(value bytes) { CAMLparam1(bytes); int b = Int_val(bytes); c_heap_t c = {NULL}; c.ptr = malloc(b); value v = caml_alloc_custom(&c_heap_t_custom_ops, sizeof(c_heap_t), 0, 1); C_heap_val(v) = c; CAMLreturn(v); } /* get the native size of an int */ value c_get_size_of_int(value unit) { CAMLparam1(unit); CAMLreturn(Val_int(sizeof(int))); } /* write an int at offset bytes from cht.ptr */ value c_write_at_offset(value cht, value offset, value intdata) { CAMLparam3(cht, offset, intdata); c_heap_t c = C_heap_val(cht); int o = Int_val(offset); int i = Int_val(intdata); int* pi = &i; memcpy(c.ptr + o, pi, sizeof(int)); CAMLreturn(Val_unit); } /* read an int at offset bytes from cht.ptr */ value c_read_at_offset(value cht, value offset) { CAMLparam2(cht, offset); c_heap_t c = C_heap_val(cht); int o = Int_val(offset); int* pi = malloc(sizeof(int)); memcpy(&pi, c.ptr + o, sizeof(int)); CAMLreturn(Val_int(pi)); } value c_dump_test_struct(value cht) { CAMLparam1(cht); c_heap_t c = C_heap_val(cht); triple_t t; memcpy(&t, c.ptr, sizeof(triple_t)); printf("C:\tx=%d, y=%d, z=%d

", t.x, t.y, t.z); CAMLreturn(Val_unit); }

Pay attention to the struct at lines 26-31 – my strategy is to write “helper” routines in C to get and set data at an offset from the start of a heap-allocated chunk of memory, which I will hold a pointer to on the OCaml side (in practice, this would probably be shared memory); that structure is the only thing that I should need to “know” to write a new application, so that with the helpers in place, any new code can be pure OCaml.

open Printf type c_ptr (* allocate n bytes of memory and return a pointer *) external alloc_heap_memory: int -> c_ptr = "c_alloc_heap_memory" (* find out what C thinks the size of an int is *) external get_size_of_int: unit -> int = "c_get_size_of_int" (* write an int into a preallocated block of memory *) external write_at_offset: c_ptr -> int -> int -> unit = "c_write_at_offset" (* test that the values arrive as expected *) external dump_test_struct: c_ptr -> unit = "c_dump_test_struct" (* dismantle the struct again *) external read_at_offset: c_ptr -> int -> int = "c_read_at_offset" (* write values 3, 5 and 7 to C *) let () = let soi = get_size_of_int () in let cht = alloc_heap_memory (3 * soi) in write_at_offset cht (0 * soi) 3; write_at_offset cht (1 * soi) 5; write_at_offset cht (2 * soi) 7; dump_test_struct cht; (* now read them back again *) let x = read_at_offset cht (0 * soi) in let y = read_at_offset cht (1 * soi) in let z = read_at_offset cht (2 * soi) in printf "OCaml:\tx=%d, y=%d, z=%d

" x y z

So knowing only that I have a structure of three int values in C, I construct and dissect it by finding the size of each one in bytes and then stepping through it in OCaml:

$ ocamlc -c c_side.c $ ocamlc -custom -o test ml_side.ml c_side.o $ ./test C: x=3, y=5, z=7 OCaml: x=3, y=5, z=7

Trivial perhaps, but it validates the approach, and will serve as a foundation to build on with more interesting data structures.