| Description | Hi,
I'd like to see a function caml_unregister_frametable that removes a frame table that was previously registered.
Background: I'm currently experimenting with a JIT compiler where the input is an algebraic expression and the output machine code. The resulting code can be called as OCaml function, and the code mainly calls other OCaml functions. A very simple generator, and it works well so far, with a little drawback: one cannot deallocate the generated code anymore, because there is no way to unregister the also generated frametable from the OCaml runtime.
caml_unregister_frametable would just have to remove the table from the linked list "frametables", and create the hash tables again. Simple to do, and I will happily provide a patch if this wish is granted. |
| Additional Information | Of course, I know I depend on the internal calling conventions of OCaml, and the JIT compiler will always be very specific to the OCaml version.
The intention of the JIT compiler is to remove interpretation overhead, especially the cost of random indirect jumps. Even with the minimalistic approach I'm currently following, I see already speedups.
Why the need for deallocation of generated code? The compiler is also used in server context where the expressions to compile come from a client.
I'm doing this right now for a company, but there is hope that I can release the compiler, hopefully driving the discussion. |
| Attached Files |  ocaml-frametable.patch [^] (4,244 bytes) 2012-07-17 16:36 [Show Content] [Hide Content]--- asmrun/stack.h.orig 2012-07-17 15:36:26.000000000 +0200
+++ asmrun/stack.h 2012-07-17 15:37:25.000000000 +0200
@@ -84,6 +84,7 @@
extern void caml_init_frame_descriptors(void);
extern void caml_register_frametable(intnat *);
+extern void caml_unregister_frametable(intnat *);
extern void caml_register_dyn_global(void *);
extern uintnat caml_stack_usage (void);
--- asmrun/roots.c.orig 2012-07-17 15:02:36.000000000 +0200
+++ asmrun/roots.c 2012-07-17 15:48:18.000000000 +0200
@@ -37,6 +37,8 @@
frame_descr ** caml_frame_descriptors = NULL;
int caml_frame_descriptors_mask;
+int caml_frame_descriptors_headroom = 0;
+int caml_frame_descriptors_factor = 2;
/* Linked-list */
@@ -59,10 +61,49 @@
static link *frametables = NULL;
+static void caml_add_frame_descriptor(intnat *tbl) ;
+
void caml_register_frametable(intnat *table) {
+ intnat len;
frametables = cons(table,frametables);
if (NULL != caml_frame_descriptors) {
+ /* This is a dynamic addition, so increase the factor to get headroom */
+ caml_frame_descriptors_factor = 4;
+
+ /* Is it ok to add the table, or do we need to rebuild? */
+ len = *table;
+ if (len <= caml_frame_descriptors_headroom) {
+ caml_frame_descriptors_headroom -= len;
+ caml_add_frame_descriptor(table);
+ } else {
+ caml_stat_free(caml_frame_descriptors);
+ caml_frame_descriptors = NULL;
+ /* force caml_init_frame_descriptors to be called */
+ }
+ }
+}
+
+void caml_unregister_frametable(intnat *table) {
+ link *lnk, *last, *entry, *entry_last;
+
+ last = NULL;
+ entry = NULL;
+ entry_last = NULL;
+ iter_list(frametables,lnk) {
+ if (lnk->data == (void *) table) {
+ entry = lnk;
+ entry_last = last;
+ }
+ last = lnk;
+ }
+
+ if (entry != NULL) {
+ if (entry_last != NULL)
+ entry_last->next = entry->next;
+ else
+ frametables->next = entry->next;
+ caml_stat_free(entry);
caml_stat_free(caml_frame_descriptors);
caml_frame_descriptors = NULL;
/* force caml_init_frame_descriptors to be called */
@@ -71,11 +112,7 @@
void caml_init_frame_descriptors(void)
{
- intnat num_descr, tblsize, i, j, len;
- intnat * tbl;
- frame_descr * d;
- uintnat nextd;
- uintnat h;
+ intnat num_descr, tblsize, i;
link *lnk;
static int inited = 0;
@@ -93,9 +130,11 @@
}
/* The size of the hashtable is a power of 2 greater or equal to
- 2 times the number of descriptors */
+ caml_frame_descriptors_factor times the number of descriptors */
tblsize = 4;
- while (tblsize < 2 * num_descr) tblsize *= 2;
+ while (tblsize < caml_frame_descriptors_factor * num_descr) tblsize *= 2;
+ /* Calculate headroom for dynamic additions */
+ caml_frame_descriptors_headroom = tblsize - (2 * num_descr);
/* Allocate the hash table */
caml_frame_descriptors =
@@ -105,23 +144,32 @@
/* Fill the hash table */
iter_list(frametables,lnk) {
- tbl = (intnat*) lnk->data;
- len = *tbl;
- d = (frame_descr *)(tbl + 1);
- for (j = 0; j < len; j++) {
- h = Hash_retaddr(d->retaddr);
- while (caml_frame_descriptors[h] != NULL) {
- h = (h+1) & caml_frame_descriptors_mask;
- }
- caml_frame_descriptors[h] = d;
- nextd =
- ((uintnat)d +
- sizeof(char *) + sizeof(short) + sizeof(short) +
- sizeof(short) * d->num_live + sizeof(frame_descr *) - 1)
- & -sizeof(frame_descr *);
- if (d->frame_size & 1) nextd += 8;
- d = (frame_descr *) nextd;
+ caml_add_frame_descriptor((intnat *) lnk->data);
+ }
+}
+
+static void caml_add_frame_descriptor(intnat *tbl)
+{
+ intnat len, j;
+ frame_descr * d;
+ uintnat nextd;
+ uintnat h;
+
+ len = *tbl;
+ d = (frame_descr *)(tbl + 1);
+ for (j = 0; j < len; j++) {
+ h = Hash_retaddr(d->retaddr);
+ while (caml_frame_descriptors[h] != NULL) {
+ h = (h+1) & caml_frame_descriptors_mask;
}
+ caml_frame_descriptors[h] = d;
+ nextd =
+ ((uintnat)d +
+ sizeof(char *) + sizeof(short) + sizeof(short) +
+ sizeof(short) * d->num_live + sizeof(frame_descr *) - 1)
+ & -sizeof(frame_descr *);
+ if (d->frame_size & 1) nextd += 8;
+ d = (frame_descr *) nextd;
}
}
|
Relationships 
Relationships 