Use Julia's finalizer implementation

.gitignore

@@ -1,3 +1,4 @@
 .idea/
 julia/*.o
-.vscode
+julia/*.dbj.obj
+.vscode

julia/mmtk_julia.c

@@ -346,61 +346,39 @@ size_t get_so_size(void* obj_raw)
     return 0;
 }
 
-void run_finalizer_function(void *o_raw, void *ff_raw, bool is_ptr)
-{
-    jl_value_t *o = (jl_value_t*) o_raw;
-    jl_value_t *ff = (jl_value_t*) ff_raw;
-    if (is_ptr) {
-        run_finalizer(jl_current_task, (jl_value_t *)(((uintptr_t)o) | 1), (jl_value_t *)ff);
-    } else {
-        run_finalizer(jl_current_task, (jl_value_t *) o, (jl_value_t *)ff);
+extern void run_finalizers(jl_task_t *ct);
+
+// Called after GC to run finalizers
+void mmtk_jl_run_finalizers(void* ptls_raw) {
+    jl_ptls_t ptls = (jl_ptls_t) ptls_raw;
+    if (!ptls->finalizers_inhibited && ptls->locks.len == 0) {
+        JL_TIMING(GC, GC_Finalizers);
+        run_finalizers(jl_current_task);
     }
 }
 
+// We implement finalization in the binding side. These functions
+// returns some pointers so MMTk can manipulate finalizer lists.
+
+extern jl_mutex_t finalizers_lock;
+extern arraylist_t to_finalize;
+extern arraylist_t finalizer_list_marked;
 
-static inline void mmtk_jl_run_finalizers_in_list(bool at_exit) {
-    jl_task_t* ct = jl_current_task;
-    uint8_t sticky = ct->sticky;
-    mmtk_run_finalizers(at_exit);
-     ct->sticky = sticky;
+void* get_thread_finalizer_list(void* ptls_raw) {
+    jl_ptls_t ptls = (jl_ptls_t) ptls_raw;
+    return (void*)&ptls->finalizers;
 }
 
-void mmtk_jl_run_pending_finalizers(void* ptls) {
-    if (!((jl_ptls_t)ptls)->in_finalizer && !((jl_ptls_t)ptls)->finalizers_inhibited && ((jl_ptls_t)ptls)->locks.len == 0) {
-        jl_task_t *ct = jl_current_task;
-        ((jl_ptls_t)ptls)->in_finalizer = 1;
-        uint64_t save_rngState[JL_RNG_SIZE];
-        memcpy(&save_rngState[0], &ct->rngState[0], sizeof(save_rngState));
-        jl_rng_split(ct->rngState, finalizer_rngState);
-        jl_atomic_store_relaxed(&jl_gc_have_pending_finalizers, 0);
-        mmtk_jl_run_finalizers_in_list(false);
-        memcpy(&ct->rngState[0], &save_rngState[0], sizeof(save_rngState));
-        ((jl_ptls_t)ptls)->in_finalizer = 0;
-    }
+void* get_to_finalize_list(void) {
+    return (void*)&to_finalize;
 }
 
-void mmtk_jl_run_finalizers(void* ptls) {
-    // Only disable finalizers on current thread
-    // Doing this on all threads is racy (it's impossible to check
-    // or wait for finalizers on other threads without dead lock).
-    if (!((jl_ptls_t)ptls)->finalizers_inhibited && ((jl_ptls_t)ptls)->locks.len == 0) {
-        jl_task_t *ct = jl_current_task;
-        int8_t was_in_finalizer = ((jl_ptls_t)ptls)->in_finalizer;
-        ((jl_ptls_t)ptls)->in_finalizer = 1;
-        uint64_t save_rngState[JL_RNG_SIZE];
-        memcpy(&save_rngState[0], &ct->rngState[0], sizeof(save_rngState));
-        jl_rng_split(ct->rngState, finalizer_rngState);
-        jl_atomic_store_relaxed(&jl_gc_have_pending_finalizers, 0);
-        mmtk_jl_run_finalizers_in_list(false);
-        memcpy(&ct->rngState[0], &save_rngState[0], sizeof(save_rngState));
-        ((jl_ptls_t)ptls)->in_finalizer = was_in_finalizer;
-    } else {
-        jl_atomic_store_relaxed(&jl_gc_have_pending_finalizers, 1);
-    }
+void* get_marked_finalizers_list(void) {
+    return (void*)&finalizer_list_marked;
 }
 
-void mmtk_jl_gc_run_all_finalizers(void) {
-    mmtk_jl_run_finalizers_in_list(true);
+int* get_jl_gc_have_pending_finalizers(void) {
+    return (int*)&jl_gc_have_pending_finalizers;
 }
 
 // add the initial root set to mmtk roots
@@ -928,7 +906,7 @@ Julia_Upcalls mmtk_upcalls = (Julia_Upcalls) {
     .scan_julia_exc_obj = scan_julia_exc_obj,
     .get_stackbase = get_stackbase,
     .calculate_roots = calculate_roots,
-    .run_finalizer_function = run_finalizer_function,
+    // .run_finalizer_function = run_finalizer_function,
     .get_jl_last_err = get_jl_last_err,
     .set_jl_last_err = set_jl_last_err,
     .get_lo_size = get_lo_size,
@@ -946,4 +924,9 @@ Julia_Upcalls mmtk_upcalls = (Julia_Upcalls) {
     .jl_hrtime = jl_hrtime,
     .update_gc_time = update_gc_time,
     .get_abi_structs_checksum_c = get_abi_structs_checksum_c,
+    .get_thread_finalizer_list = get_thread_finalizer_list,
+    .get_to_finalize_list = get_to_finalize_list,
+    .get_marked_finalizers_list = get_marked_finalizers_list,
+    .arraylist_grow = (void (*)(void*, long unsigned int))arraylist_grow,
+    .get_jl_gc_have_pending_finalizers = get_jl_gc_have_pending_finalizers,
 };

mmtk/Cargo.toml

@@ -10,15 +10,17 @@ edition = "2018"
 [package.metadata.julia]
 # Our CI matches the following line and extract mmtk/julia. If this line is updated, please check ci yaml files and make sure it works.
 julia_repo = "https://github.com/mmtk/julia.git"
-julia_version = "81bda9cc0c936ba1ec7bbfee5e6a05bee7b45b2d"
+julia_version = "f690aa3a5621bfa1d6a07f911818f203d3f8d650"
 
 [lib]
-crate-type = ["staticlib", "rlib", "dylib"]
+crate-type = ["cdylib"]
 
 [build-dependencies]
 cc = "*"
 built = "*"
 
+[profile.release]
+lto = true
 
 [dependencies]
 libc = "0.2"

mmtk/api/mmtk.h

@@ -72,7 +72,6 @@ typedef struct {
     void (* scan_julia_exc_obj) (void* obj, closure_pointer closure, ProcessEdgeFn process_edge);
     void* (* get_stackbase) (int16_t tid);
     void (* calculate_roots) (void* tls);
-    void (* run_finalizer_function) (void* obj, void* function, bool is_ptr);
     int (* get_jl_last_err) (void);
     void (* set_jl_last_err) (int e);
     size_t (* get_lo_size) (void* obj);
@@ -90,6 +89,11 @@ typedef struct {
     uint64_t (* jl_hrtime) (void);
     void (* update_gc_time) (uint64_t);
     uintptr_t (* get_abi_structs_checksum_c) (void);
+    void* (* get_thread_finalizer_list) (void* tls);
+    void* (* get_to_finalize_list)(void);
+    void* (* get_marked_finalizers_list)(void);
+    void (*arraylist_grow)(void* a, size_t n);
+    int* (*get_jl_gc_have_pending_finalizers)(void);
 } Julia_Upcalls;
 
 /**