vgc: 10% speed up

Author: medvednikov

bench/README.md

@@ -5,7 +5,8 @@ V version: 0.5.1.
 
 ## GC: Boehm vs VGC
 
-Compares Boehm GC (`-gc boehm`) against V's built-in concurrent tri-color mark-and-sweep (`-gc vgc`).
+Compares Boehm GC (`-gc boehm`) against V's built-in concurrent tri-color
+mark-and-sweep (`-gc vgc`).
 5 iterations per test, median reported.
 
 ```
@@ -15,18 +16,18 @@ v run bench/bench_gc.v
 ```
   test                                             boehm       vgc     ratio
   ———————————————————————————————————————————— ————————— ————————— —————————
-  small allocs (1000000x string)                   41 ms     59 ms    1.44x
-  tree build+walk (depth=18, 10x)                  49 ms    156 ms    3.18x
-  array grow (100x 100000 pushes)                   8 ms     33 ms    4.13x
-  map insert (20x 10k entries)                     20 ms     31 ms    1.55x
-  mixed workload (50 rounds)                       10 ms     21 ms    2.10x
+  small allocs (1000000x string)                   43 ms     52 ms    1.21x
+  tree build+walk (depth=18, 10x)                  46 ms    125 ms    2.72x
+  array grow (100x 100000 pushes)                   7 ms     30 ms    4.29x
+  map insert (20x 10k entries)                     20 ms     27 ms    1.35x
+  mixed workload (50 rounds)                       10 ms     16 ms    1.60x
 
   heap usage:
-    boehm: 29856 KB allocated, 29312 KB free
+    boehm: 29856 KB allocated, 29020 KB free
     vgc:   131072 KB allocated, 0 KB free
 ```
 
-Boehm is 1.4x-4x faster across all workloads and uses ~4x less heap.
+Boehm is still 1.2x-4.3x faster across these workloads and uses ~4x less heap.
 
 ## Closures
 

thirdparty/vgc/vgc_platform.h

@@ -112,6 +112,59 @@ static inline void vgc_set_cache_idx(int idx) { _vgc_cache_idx = idx; }
   static inline void* vgc_get_sp(void) { return __builtin_frame_address(0); }
 #endif
 
+// ============================================================
+// Stack bounds
+// ============================================================
+#if defined(__APPLE__)
+  #include <pthread.h>
+  static inline int vgc_get_stack_bounds(uintptr_t* lo, uintptr_t* hi) {
+      void* stack_hi = pthread_get_stackaddr_np(pthread_self());
+      size_t stack_size = pthread_get_stacksize_np(pthread_self());
+      if (stack_hi == NULL || stack_size == 0) return 0;
+      *hi = (uintptr_t)stack_hi;
+      *lo = *hi - stack_size;
+      return 1;
+  }
+#elif defined(__linux__) || defined(__ANDROID__)
+  #include <pthread.h>
+  static inline int vgc_get_stack_bounds(uintptr_t* lo, uintptr_t* hi) {
+      pthread_attr_t attr;
+      if (pthread_getattr_np(pthread_self(), &attr) != 0) return 0;
+      void* stack_lo = NULL;
+      size_t stack_size = 0;
+      int ok = pthread_attr_getstack(&attr, &stack_lo, &stack_size) == 0 && stack_lo != NULL && stack_size != 0;
+      pthread_attr_destroy(&attr);
+      if (!ok) return 0;
+      *lo = (uintptr_t)stack_lo;
+      *hi = *lo + stack_size;
+      return 1;
+  }
+#elif defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OpenBSD__)
+  #include <pthread.h>
+  static inline int vgc_get_stack_bounds(uintptr_t* lo, uintptr_t* hi) {
+      pthread_attr_t attr;
+      if (pthread_attr_init(&attr) != 0) return 0;
+      if (pthread_attr_get_np(pthread_self(), &attr) != 0) {
+          pthread_attr_destroy(&attr);
+          return 0;
+      }
+      void* stack_lo = NULL;
+      size_t stack_size = 0;
+      int ok = pthread_attr_getstack(&attr, &stack_lo, &stack_size) == 0 && stack_lo != NULL && stack_size != 0;
+      pthread_attr_destroy(&attr);
+      if (!ok) return 0;
+      *lo = (uintptr_t)stack_lo;
+      *hi = *lo + stack_size;
+      return 1;
+  }
+#else
+  static inline int vgc_get_stack_bounds(uintptr_t* lo, uintptr_t* hi) {
+      (void)lo;
+      (void)hi;
+      return 0;
+  }
+#endif
+
 // ============================================================
 // Bitmap operations (for mark/alloc bitmaps)
 // ============================================================

vlib/builtin/array_d_gcboehm_opt.v

@@ -120,7 +120,7 @@ fn (mut a array) ensure_cap_noscan(required int) {
 		}
 	}
 	new_size := u64(cap) * u64(a.element_size)
-	new_data := vcalloc_noscan(new_size)
+	new_data := unsafe { malloc_noscan(__at_least_one(new_size)) }
 	if a.data != unsafe { nil } {
 		unsafe { vmemcpy(new_data, a.data, u64(a.len) * u64(a.element_size)) }
 		// TODO: the old data may be leaked when no GC is used (ref-counting?)