Remove MMTk counted malloc (#24)

This PR changes the implementation of malloc methods for MMTk. We no longer use malloc and counted malloc methods from MMTk for those. Instead, we maintain a global counter for the size, and report the size to MMTk.

Author: qinsoon

src/gc.h

@@ -33,10 +33,11 @@
 extern void maybe_collect(jl_ptls_t ptls);
 extern void run_finalizer(jl_task_t *ct, void *o, void *ff);
 extern void *jl_malloc_aligned(size_t sz, size_t align);
+extern void *jl_realloc_aligned(void *d, size_t sz, size_t oldsz, size_t align);
+extern void jl_free_aligned(void *p);
 extern void *jl_gc_counted_calloc(size_t nm, size_t sz);
 extern void jl_gc_counted_free_with_size(void *p, size_t sz);
 extern void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size_t sz);
-extern void *jl_realloc_aligned(void *d, size_t sz, size_t oldsz, size_t align);
 extern void jl_gc_add_finalizer_th(jl_ptls_t ptls, jl_value_t *v, jl_function_t *f);
 extern void jl_finalize_th(jl_task_t *ct, jl_value_t *o);
 extern jl_weakref_t *jl_gc_new_weakref_th(jl_ptls_t ptls, jl_value_t *value);
@@ -47,6 +48,7 @@ extern void gc_premark(jl_ptls_t ptls2);
 extern void *gc_managed_realloc_(jl_ptls_t ptls, void *d, size_t sz, size_t oldsz,
                                  int isaligned, jl_value_t *owner, int8_t can_collect);
 extern size_t jl_array_nbytes(jl_array_t *a);
+extern void run_finalizers(jl_task_t *ct);
 
 #ifdef OBJPROFILE
 void objprofile_count(void *ty, int old, int sz) JL_NOTSAFEPOINT;

src/mmtk-gc.c

@@ -53,31 +53,56 @@ static inline void malloc_maybe_collect(jl_ptls_t ptls, size_t sz)
     }
 }
 
-
 // malloc wrappers, aligned allocation
-// ---
+// We currently just duplicate what Julia GC does. We will in the future replace the malloc calls with MMTK's malloc.
 
+#if defined(_OS_WINDOWS_)
+inline void *jl_malloc_aligned(size_t sz, size_t align)
+{
+    return _aligned_malloc(sz ? sz : 1, align);
+}
+inline void *jl_realloc_aligned(void *p, size_t sz, size_t oldsz,
+                                       size_t align)
+{
+    (void)oldsz;
+    return _aligned_realloc(p, sz ? sz : 1, align);
+}
+inline void jl_free_aligned(void *p) JL_NOTSAFEPOINT
+{
+    _aligned_free(p);
+}
+#else
 inline void *jl_malloc_aligned(size_t sz, size_t align)
 {
-    return mmtk_malloc_aligned(sz ? sz : 1, align); // XXX sz
+#if defined(_P64) || defined(__APPLE__)
+    if (align <= 16)
+        return malloc(sz);
+#endif
+    void *ptr;
+    if (posix_memalign(&ptr, align, sz))
+        return NULL;
+    return ptr;
 }
 inline void *jl_realloc_aligned(void *d, size_t sz, size_t oldsz,
                                        size_t align)
 {
-    void *res = jl_malloc_aligned(sz, align);
-    if (res != NULL) {
-        memcpy(res, d, oldsz > sz ? sz : oldsz);
-        mmtk_free_aligned(d);
+#if defined(_P64) || defined(__APPLE__)
+    if (align <= 16)
+        return realloc(d, sz);
+#endif
+    void *b = jl_malloc_aligned(sz, align);
+    if (b != NULL) {
+        memcpy(b, d, oldsz > sz ? sz : oldsz);
+        free(d);
     }
-    return res;
+    return b;
 }
 inline void jl_free_aligned(void *p) JL_NOTSAFEPOINT
 {
-    mmtk_free_aligned(p);
+    free(p);
 }
+#endif
 
-
-// finalizers
 // ---
 
 JL_DLLEXPORT void jl_gc_run_pending_finalizers(jl_task_t *ct)
@@ -195,15 +220,14 @@ void jl_gc_free_array(jl_array_t *a) JL_NOTSAFEPOINT
     if (a->flags.how == 2) {
         char *d = (char*)a->data - a->offset*a->elsize;
         if (a->flags.isaligned)
-            mmtk_free_aligned(d);
+            jl_free_aligned(d);
         else
-            mmtk_free(d);
+            free(d);
         gc_num.freed += jl_array_nbytes(a);
         gc_num.freecall++;
     }
 }
 
-
 // roots
 // ---
 
@@ -384,11 +408,7 @@ JL_DLLEXPORT void *jl_gc_counted_malloc(size_t sz)
     if (pgcstack && ct->world_age) {
         jl_ptls_t ptls = ct->ptls;
         malloc_maybe_collect(ptls, sz);
-        jl_atomic_store_relaxed(&ptls->gc_num.allocd,
-            jl_atomic_load_relaxed(&ptls->gc_num.allocd) + sz);
-        jl_atomic_store_relaxed(&ptls->gc_num.malloc,
-            jl_atomic_load_relaxed(&ptls->gc_num.malloc) + 1);
-        return mmtk_counted_malloc(sz);
+        jl_atomic_fetch_add_relaxed(&JULIA_MALLOC_BYTES, sz);
     }
     return malloc(sz);
 }
@@ -399,12 +419,8 @@ JL_DLLEXPORT void *jl_gc_counted_calloc(size_t nm, size_t sz)
     jl_task_t *ct = jl_current_task;
     if (pgcstack && ct->world_age) {
         jl_ptls_t ptls = ct->ptls;
-        malloc_maybe_collect(ptls, sz);
-        jl_atomic_store_relaxed(&ptls->gc_num.allocd,
-            jl_atomic_load_relaxed(&ptls->gc_num.allocd) + nm*sz);
-        jl_atomic_store_relaxed(&ptls->gc_num.malloc,
-            jl_atomic_load_relaxed(&ptls->gc_num.malloc) + 1);
-        return mmtk_counted_calloc(nm, sz);
+        malloc_maybe_collect(ptls, nm * sz);
+        jl_atomic_fetch_add_relaxed(&JULIA_MALLOC_BYTES, nm * sz);
     }
     return calloc(nm, sz);
 }
@@ -413,16 +429,10 @@ JL_DLLEXPORT void jl_gc_counted_free_with_size(void *p, size_t sz)
 {
     jl_gcframe_t **pgcstack = jl_get_pgcstack();
     jl_task_t *ct = jl_current_task;
+    free(p);
     if (pgcstack && ct->world_age) {
-        jl_ptls_t ptls = ct->ptls;
-        jl_atomic_store_relaxed(&ptls->gc_num.freed,
-            jl_atomic_load_relaxed(&ptls->gc_num.freed) + sz);
-        jl_atomic_store_relaxed(&ptls->gc_num.freecall,
-            jl_atomic_load_relaxed(&ptls->gc_num.freecall) + 1);
-        mmtk_free_with_size(p, sz);
-        return;
+        jl_atomic_fetch_add_relaxed(&JULIA_MALLOC_BYTES, -sz);
     }
-    free(p);
 }
 
 JL_DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size_t sz)
@@ -433,16 +443,10 @@ JL_DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size
         jl_ptls_t ptls = ct->ptls;
         malloc_maybe_collect(ptls, sz);
         if (sz < old)
-            jl_atomic_store_relaxed(&ptls->gc_num.freed,
-                jl_atomic_load_relaxed(&ptls->gc_num.freed) + (old - sz));
+            jl_atomic_fetch_add_relaxed(&JULIA_MALLOC_BYTES, old - sz);
         else
-            jl_atomic_store_relaxed(&ptls->gc_num.allocd,
-                jl_atomic_load_relaxed(&ptls->gc_num.allocd) + (sz - old));
-        jl_atomic_store_relaxed(&ptls->gc_num.realloc,
-            jl_atomic_load_relaxed(&ptls->gc_num.realloc) + 1);
-        return mmtk_realloc_with_old_size(p, sz, old);
+            jl_atomic_fetch_add_relaxed(&JULIA_MALLOC_BYTES, sz - old);
     }
-    // TODO: correct?
     return realloc(p, sz);
 }