cgen: lower Boehm GC free-space divisor to 1 for the opt modes (fix #27555)

Allocation-heavy multithreaded HTTP servers regressed on the default GC after
thread-local allocation (#27544) removed the allocator-lock bottleneck: with the
fast path no longer serializing on the global lock, the remaining bottleneck is
Boehm's stop-the-world collections, which each pause every worker thread.

The optimized GC modes kept the heap small via GC_set_free_space_divisor(2),
which makes those collections frequent. Lower it to 1 so the heap may grow to
roughly the live set before collecting, cutting stop-the-world pauses ~3x. It is
still emitted before GC_INIT(), so a user GC_FREE_SPACE_DIVISOR env var overrides
it and memory-constrained programs can raise it again.

Measured on a 10-core machine, single-allocation JSON workload:
  - multithreaded: +21% throughput (1.79M -> 2.17M rps)
  - single-threaded: 3.3x fewer collections (7277 -> 2224 per 2M requests)

Author: medvednikov

vlib/v/gen/c/cmain.v

@@ -161,7 +161,13 @@ fn (mut g Gen) gen_boehm_gc_init() {
 	}
 	g.writeln('\tGC_set_pages_executable(0);')
 	if g.pref.gc_mode in [.boehm_full_opt, .boehm_incr_opt] {
-		g.writeln('\tGC_set_free_space_divisor(2);')
+		// Let the heap grow to roughly the live set before collecting, instead of
+		// keeping it small. A smaller divisor means rarer stop-the-world pauses;
+		// with thread-local allocation those pauses (not the allocator lock) are
+		// what serializes worker threads on allocation-heavy multithreaded servers
+		// (issue #27555). Emitted before GC_INIT(), so a user `GC_FREE_SPACE_DIVISOR`
+		// env var still wins and memory-constrained programs can raise it again.
+		g.writeln('\tGC_set_free_space_divisor(1);')
 	}
 	if g.pref.use_coroutines {
 		g.writeln('\tGC_allow_register_threads();')
@@ -190,7 +196,9 @@ fn (mut g Gen) gen_shared_library_boehm_init() {
 	// equivalent restriction applies to Windows DLLs.
 	g.writeln('\tGC_set_pages_executable(0);')
 	if g.pref.gc_mode in [.boehm_full_opt, .boehm_incr_opt] {
-		g.writeln('\tGC_set_free_space_divisor(2);')
+		// See gen_boehm_gc_init: rarer stop-the-world pauses for the opt modes,
+		// overridable via the `GC_FREE_SPACE_DIVISOR` env var (issue #27555).
+		g.writeln('\tGC_set_free_space_divisor(1);')
 	}
 	g.writeln('\tGC_INIT();')
 	g.writeln('\tGC_register_displacement(sizeof(void*));')

vlib/v/tests/gc_free_space_divisor_test.v

@@ -0,0 +1,24 @@
+// Regression test for issue #27555: on the optimized `-gc` modes (the default
+// `boehm_full_opt`), `main()` calls `GC_set_free_space_divisor(1)` before
+// `GC_INIT()`, so the heap is allowed to grow to roughly the live set before
+// collecting. That keeps stop-the-world collections rare, which with thread-local
+// allocation is what otherwise serializes worker threads on allocation-heavy
+// multithreaded HTTP servers. An explicit `GC_FREE_SPACE_DIVISOR` env var is
+// applied by `GC_INIT()` afterwards and wins, so the test skips when one is set.
+import os
+
+fn C.GC_get_free_space_divisor() usize
+
+fn test_free_space_divisor_is_tuned_for_throughput() {
+	$if gcboehm_opt ? {
+		if os.getenv('GC_FREE_SPACE_DIVISOR') != '' {
+			eprintln('skipping: explicit GC_FREE_SPACE_DIVISOR override is set')
+			assert true
+			return
+		}
+		assert C.GC_get_free_space_divisor() == 1
+	} $else {
+		eprintln('skipping: not an optimized boehm GC build')
+		assert true
+	}
+}