WIP: pass type of allocated value to GC functions.

Maybe makes it possible to get rid of set_typeof call in generated code.

Author: maleadt

src/array.c

@@ -337,9 +337,8 @@ JL_DLLEXPORT jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data,
     if (own_buffer) {
         a->flags.how = 2;
         jl_gc_track_malloced_array(ptls, a);
-        jl_gc_count_allocd(a, nel*elsz + (elsz == 1 ? 1 : 0),
+        jl_gc_count_allocd(a, nel*elsz + (elsz == 1 ? 1 : 0), atype,
                            JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_STDALLOC);
-        jl_memprofile_set_typeof(a, atype);
     }
     else {
         a->flags.how = 0;
@@ -406,9 +405,8 @@ JL_DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data,
     if (own_buffer) {
         a->flags.how = 2;
         jl_gc_track_malloced_array(ptls, a);
-        jl_gc_count_allocd(a, nel*elsz + (elsz == 1 ? 1 : 0),
+        jl_gc_count_allocd(a, nel*elsz + (elsz == 1 ? 1 : 0), atype,
                            JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_STDALLOC);
-        jl_memprofile_set_typeof(a, atype);
     }
     else {
         a->flags.how = 0;

src/gc.c

@@ -878,7 +878,7 @@ static void sweep_weak_refs(void)
 // big value list
 
 // Size includes the tag and the tag is not cleared!!
-JL_DLLEXPORT jl_value_t *jl_gc_big_alloc(jl_ptls_t ptls, size_t sz)
+JL_DLLEXPORT jl_value_t *jl_gc_big_alloc(jl_ptls_t ptls, size_t sz, void *ty)
 {
     maybe_collect(ptls);
     size_t offs = offsetof(bigval_t, header);
@@ -893,8 +893,8 @@ JL_DLLEXPORT jl_value_t *jl_gc_big_alloc(jl_ptls_t ptls, size_t sz)
         jl_throw(jl_memory_exception);
     gc_invoke_callbacks(jl_gc_cb_notify_external_alloc_t,
         gc_cblist_notify_external_alloc, (v, allocsz));
-    jl_gc_count_allocd(jl_valueof(&v->header), allocsz, JL_MEMPROF_TAG_DOMAIN_CPU |
-                                                        JL_MEMPROF_TAG_ALLOC_BIGALLOC);
+    jl_gc_count_allocd(jl_valueof(&v->header), allocsz, ty,
+                                  JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_BIGALLOC);
     ptls->gc_num.bigalloc++;
 #ifdef MEMDEBUG
     memset(v, 0xee, allocsz);
@@ -986,13 +986,13 @@ void jl_gc_track_malloced_array(jl_ptls_t ptls, jl_array_t *a) JL_NOTSAFEPOINT
     ptls->heap.mallocarrays = ma;
 }
 
-void jl_gc_count_allocd(void * addr, size_t sz, uint16_t tag) JL_NOTSAFEPOINT
+void jl_gc_count_allocd(void * addr, size_t sz, void *ty, uint16_t tag) JL_NOTSAFEPOINT
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     ptls->gc_num.allocd += sz;
 
     if (__unlikely(jl_memprofile_is_running())) {
-        jl_memprofile_track_alloc(addr, tag, sz);
+        jl_memprofile_track_alloc(addr, tag, sz, ty);
     }
 }
 
@@ -1006,7 +1006,8 @@ void jl_gc_count_freed(void * addr, size_t sz, uint16_t tag) JL_NOTSAFEPOINT
     }
 }
 
-void jl_gc_count_reallocd(void * oldaddr, size_t oldsz, void * newaddr, size_t newsz, uint16_t tag) JL_NOTSAFEPOINT
+void jl_gc_count_reallocd(void * oldaddr, size_t oldsz, void * newaddr, size_t newsz,
+                          void *newty, uint16_t tag) JL_NOTSAFEPOINT
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     if (oldsz < newsz) {
@@ -1022,7 +1023,7 @@ void jl_gc_count_reallocd(void * oldaddr, size_t oldsz, void * newaddr, size_t n
     // the two values when realloc'ing.
     if (__unlikely(jl_memprofile_is_running())) {
         jl_memprofile_track_dealloc(oldaddr, tag);
-        jl_memprofile_track_alloc(newaddr, tag, newsz);
+        jl_memprofile_track_alloc(newaddr, tag, newsz, newty);
     }
 }
 
@@ -1165,15 +1166,15 @@ static NOINLINE jl_taggedvalue_t *add_page(jl_gc_pool_t *p) JL_NOTSAFEPOINT
 
 // Size includes the tag and the tag is not cleared!!
 JL_DLLEXPORT jl_value_t *jl_gc_pool_alloc(jl_ptls_t ptls, int pool_offset,
-                                          int osize)
+                                          int osize, void *ty)
 {
     // Use the pool offset instead of the pool address as the argument
     // to workaround a llvm bug.
     // Ref https://llvm.org/bugs/show_bug.cgi?id=27190
     jl_gc_pool_t *p = (jl_gc_pool_t*)((char*)ptls + pool_offset);
     assert(ptls->gc_state == 0);
 #ifdef MEMDEBUG
-    return jl_gc_big_alloc(ptls, osize);
+    return jl_gc_big_alloc(ptls, osize, ty);
 #endif
     maybe_collect(ptls);
     ptls->gc_num.poolalloc++;
@@ -1190,7 +1191,7 @@ JL_DLLEXPORT jl_value_t *jl_gc_pool_alloc(jl_ptls_t ptls, int pool_offset,
             pg->nfree = 0;
             pg->has_young = 1;
         }
-        jl_gc_count_allocd(jl_valueof(v), osize, JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_POOLALLOC);
+        jl_gc_count_allocd(jl_valueof(v), osize, ty, JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_POOLALLOC);
         return jl_valueof(v);
     }
     // if the freelist is empty we reuse empty but not freed pages
@@ -1215,7 +1216,7 @@ JL_DLLEXPORT jl_value_t *jl_gc_pool_alloc(jl_ptls_t ptls, int pool_offset,
         next = (jl_taggedvalue_t*)((char*)v + osize);
     }
     p->newpages = next;
-    jl_gc_count_allocd(jl_valueof(v), osize, JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_POOLALLOC);
+    jl_gc_count_allocd(jl_valueof(v), osize, ty, JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_POOLALLOC);
     return jl_valueof(v);
 }
 
@@ -3172,7 +3173,7 @@ JL_DLLEXPORT void *jl_gc_counted_malloc(size_t sz)
         maybe_collect(ptls);
     void *b = malloc(sz);
     if (ptls && ptls->world_age) {
-        jl_gc_count_allocd(b, sz, JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_STDALLOC);
+        jl_gc_count_allocd(b, sz, NULL, JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_STDALLOC);
         ptls->gc_num.malloc++;
     }
     return b;
@@ -3185,7 +3186,7 @@ JL_DLLEXPORT void *jl_gc_counted_calloc(size_t nm, size_t sz)
         maybe_collect(ptls);
     void *b = calloc(nm, sz);
     if (ptls && ptls->world_age) {
-        jl_gc_count_allocd(b, nm*sz, JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_STDALLOC);
+        jl_gc_count_allocd(b, nm*sz, NULL, JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_STDALLOC);
         ptls->gc_num.malloc++;
     }
     return b;
@@ -3208,7 +3209,7 @@ JL_DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size
         maybe_collect(ptls);
     void *b = realloc(p, sz);
     if (ptls && ptls->world_age) {
-        jl_gc_count_reallocd(p, old, b, sz, JL_MEMPROF_TAG_DOMAIN_CPU);
+        jl_gc_count_reallocd(p, old, b, sz, NULL, JL_MEMPROF_TAG_DOMAIN_CPU);
         ptls->gc_num.realloc++;
     }
     return b;
@@ -3280,7 +3281,7 @@ JL_DLLEXPORT void *jl_gc_managed_malloc(size_t sz)
     void *b = malloc_cache_align(allocsz);
     if (b == NULL)
         jl_throw(jl_memory_exception);
-    jl_gc_count_allocd(b, allocsz, JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_STDALLOC);
+    jl_gc_count_allocd(b, allocsz, NULL, JL_MEMPROF_TAG_DOMAIN_CPU | JL_MEMPROF_TAG_ALLOC_STDALLOC);
     ptls->gc_num.malloc++;
 #ifdef _OS_WINDOWS_
     SetLastError(last_error);
@@ -3319,7 +3320,7 @@ static void *gc_managed_realloc_(jl_ptls_t ptls, void *d, size_t sz, size_t olds
         live_bytes += allocsz - oldsz;
     }
     else
-        jl_gc_count_reallocd(d, oldsz, b, allocsz, JL_MEMPROF_TAG_DOMAIN_CPU);
+        jl_gc_count_reallocd(d, oldsz, b, allocsz, NULL, JL_MEMPROF_TAG_DOMAIN_CPU);
     ptls->gc_num.realloc++;
 
 #ifdef _OS_WINDOWS_

src/julia_internal.h

@@ -135,8 +135,8 @@ JL_DLLEXPORT extern int jl_lineno;
 JL_DLLEXPORT extern const char *jl_filename;
 
 JL_DLLEXPORT jl_value_t *jl_gc_pool_alloc(jl_ptls_t ptls, int pool_offset,
-                                          int osize);
-JL_DLLEXPORT jl_value_t *jl_gc_big_alloc(jl_ptls_t ptls, size_t allocsz);
+                                          int osize, void *ty);
+JL_DLLEXPORT jl_value_t *jl_gc_big_alloc(jl_ptls_t ptls, size_t allocsz, void *ty);
 int jl_gc_classify_pools(size_t sz, int *osize);
 extern jl_mutex_t gc_perm_lock;
 void *jl_gc_perm_alloc_nolock(size_t sz, int zero,
@@ -252,7 +252,7 @@ STATIC_INLINE uint8_t JL_CONST_FUNC jl_gc_szclass(unsigned sz)
 #define JL_MEMPROF_TAG_DEALLOC              0x8000
 
 // Necessary memory profiler prototypes
-JL_DLLEXPORT void jl_memprofile_track_alloc(void *v, uint16_t tag, size_t allocsz) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void jl_memprofile_track_alloc(void *v, uint16_t tag, size_t allocsz, void *ty) JL_NOTSAFEPOINT;
 JL_DLLEXPORT void jl_memprofile_track_dealloc(void *v, uint16_t tag) JL_NOTSAFEPOINT;
 JL_DLLEXPORT int jl_memprofile_is_running(void) JL_NOTSAFEPOINT;
 JL_DLLEXPORT void jl_memprofile_set_typeof(void * v, void * ty) JL_NOTSAFEPOINT;
@@ -275,12 +275,12 @@ STATIC_INLINE jl_value_t *jl_gc_alloc_(jl_ptls_t ptls, size_t sz, void *ty)
         int pool_id = jl_gc_szclass(allocsz);
         jl_gc_pool_t *p = &ptls->heap.norm_pools[pool_id];
         int osize = jl_gc_sizeclasses[pool_id];
-        v = jl_gc_pool_alloc(ptls, (char*)p - (char*)ptls, osize);
+        v = jl_gc_pool_alloc(ptls, (char*)p - (char*)ptls, osize, ty);
     }
     else {
         if (allocsz < sz) // overflow in adding offs, size was "negative"
             jl_throw(jl_memory_exception);
-        v = jl_gc_big_alloc(ptls, allocsz);
+        v = jl_gc_big_alloc(ptls, allocsz, ty);
     }
     jl_set_typeof(v, ty);
     jl_memprofile_set_typeof(v, ty);
@@ -348,9 +348,10 @@ JL_DLLEXPORT void JL_NORETURN jl_throw_out_of_memory_error(void);
 JL_DLLEXPORT int64_t jl_gc_diff_total_bytes(void);
 void jl_gc_sync_total_bytes(void);
 void jl_gc_track_malloced_array(jl_ptls_t ptls, jl_array_t *a) JL_NOTSAFEPOINT;
-void jl_gc_count_allocd(void * addr, size_t sz, uint16_t tag) JL_NOTSAFEPOINT;
+void jl_gc_count_allocd(void * addr, size_t sz, void *ty, uint16_t tag) JL_NOTSAFEPOINT;
 void jl_gc_count_freed(void * addr, size_t sz, uint16_t tag) JL_NOTSAFEPOINT;
-void jl_gc_count_reallocd(void * oldaddr, size_t oldsz, void * newaddr, size_t newsz, uint16_t tag) JL_NOTSAFEPOINT;
+void jl_gc_count_reallocd(void * oldaddr, size_t oldsz, void * newaddr, size_t newsz,
+                          void *newty, uint16_t tag) JL_NOTSAFEPOINT;
 void jl_gc_run_all_finalizers(jl_ptls_t ptls);
 
 void gc_queue_binding(jl_binding_t *bnd) JL_NOTSAFEPOINT;

src/profile.c

@@ -143,7 +143,7 @@ JL_DLLEXPORT jl_array_t * jl_memprofile_find_malloc_array(void * adata)
     return NULL;
 }
 
-JL_DLLEXPORT void jl_memprofile_track_alloc(void *v, uint16_t tag, size_t allocsz) JL_NOTSAFEPOINT
+JL_DLLEXPORT void jl_memprofile_track_alloc(void *v, uint16_t tag, size_t allocsz, void *ty) JL_NOTSAFEPOINT
 {
     // Filter out this call with our tag filter
     if ((tag & memprof_tag_filter) != tag)
@@ -171,9 +171,8 @@ JL_DLLEXPORT void jl_memprofile_track_alloc(void *v, uint16_t tag, size_t allocs
     jl_bt_element_t *bt_entry = (jl_bt_element_t*) bt_data_prof + bt_size_cur + bt_size_step;
     bt_entry[0].uintptr = JL_BT_NON_PTR_ENTRY;
     bt_entry[1].uintptr = entry_tags;
-    // The location of the type information for this chunk of memory (tracked value).
-    // Initially set to nothing, populated later by `jl_memprofile_set_typeof()`
-    bt_entry[2].jlvalue = (jl_value_t*)jl_nothing;
+    // The location of the type information for this chunk of memory (tracked value)
+    bt_entry[2].jlvalue = (jl_value_t*)(ty ? ty : jl_nothing);
     // The location of the data in memory, used to match allocations with deallocations.
     bt_entry[3].uintptr = (uintptr_t) v;
     // The time at which this happened
@@ -207,5 +206,5 @@ JL_DLLEXPORT void jl_memprofile_set_typeof(void * v, void * ty) JL_NOTSAFEPOINT
 
 JL_DLLEXPORT void jl_memprofile_track_dealloc(void *v, uint16_t tag) JL_NOTSAFEPOINT
 {
-    jl_memprofile_track_alloc(v, tag | JL_MEMPROF_TAG_DEALLOC, 0);
+    jl_memprofile_track_alloc(v, tag | JL_MEMPROF_TAG_DEALLOC, 0, NULL);
 }