v2: prealloc

Author: medvednikov

vlib/builtin/prealloc.c.v

@@ -89,6 +89,13 @@ fn vmemory_block_new(prev &VMemoryBlock, at_least isize, align isize) &VMemoryBl
 
 @[unsafe]
 fn vmemory_block_malloc(n isize, align isize) &u8 {
+	unsafe {
+		// Lazy per-thread initialization: when g_memory_block is thread-local,
+		// new threads start with a null pointer and need their own arena.
+		if g_memory_block == nil {
+			g_memory_block = vmemory_block_new(nil, isize(prealloc_block_size), 0)
+		}
+	}
 	$if prealloc_trace_malloc ? {
 		C.fprintf(C.stderr, c'vmemory_block_malloc g_memory_block.id: %d, n: %lld align: %d\n',
 			g_memory_block.id, n, align)

vlib/v2/gen/cleanc/cheaders.v

@@ -249,6 +249,13 @@ fn (mut g Gen) write_preamble() {
 		preamble_includes_full
 	})
 	g.emit_collected_c_directives()
+	if g.pref != unsafe { nil } && g.pref.prealloc {
+		g.sb.writeln('#define _VPREALLOC (1)')
+		// Save the real free() before redefining it as a no-op.
+		// prealloc_vcleanup needs the real free to release arena chunks.
+		g.sb.writeln('static inline void _v_cfree(void *p) { free(p); }')
+		g.sb.writeln('#define free(p) ((void)(p), (void)0)')
+	}
 	g.sb.writeln('')
 
 	// V primitive type aliases

vlib/v2/gen/cleanc/cleanc.v

@@ -461,6 +461,7 @@ fn is_builtin_runtime_keep_file(path string) bool {
 		|| normalized.ends_with('vlib/builtin/builtin.v')
 		|| normalized.ends_with('vlib/builtin/cfns_wrapper.c.v')
 		|| normalized.ends_with('vlib/builtin/allocation.c.v')
+		|| normalized.ends_with('vlib/builtin/prealloc.c.v')
 		|| normalized.ends_with('vlib/builtin/panicing.c.v')
 		|| normalized.ends_with('vlib/builtin/chan_option_result.v')
 		|| normalized.ends_with('vlib/builtin/int.v') || normalized.ends_with('vlib/builtin/rune.v')

vlib/v2/gen/cleanc/consts_and_globals.v

@@ -342,9 +342,10 @@ fn (mut g Gen) gen_const_decl_extern(node ast.ConstDecl) {
 		if value_expr.len == 0 {
 			continue
 		}
-		// Array consts with static backing data cannot be #defined across
-		// translation units. Emit extern declarations instead.
-		if value_expr.contains('__const_array_data_') {
+		// Array consts with static backing data or inline compound literals
+		// cannot be #defined across translation units. Emit extern declarations instead.
+		if value_expr.contains('__const_array_data_')
+			|| value_expr.contains('new_array_from_c_array') {
 			g.emitted_types[macro_key] = true
 			g.sb.writeln('extern array ${name};')
 			continue
@@ -436,7 +437,13 @@ fn (mut g Gen) gen_global_decl(node ast.GlobalDecl) {
 			typ = 'int'
 		}
 		g.global_var_types[name] = typ
-		g.sb.write_string('${typ} ${name}')
+		// With prealloc, g_memory_block must be thread-local so each thread
+		// gets its own arena and the bump allocator is safe without locks.
+		if name == 'g_memory_block' && g.pref != unsafe { nil } && g.pref.prealloc {
+			g.sb.write_string('_Thread_local ${typ} ${name}')
+		} else {
+			g.sb.write_string('${typ} ${name}')
+		}
 		if field.value !is ast.EmptyExpr {
 			// Function calls are not compile-time constants in C
 			if g.contains_call_expr(field.value) {
@@ -486,7 +493,11 @@ fn (mut g Gen) gen_global_decl_extern(node ast.GlobalDecl) {
 			typ = 'int'
 		}
 		g.global_var_types[name] = typ
-		g.sb.writeln('extern ${typ} ${name};')
+		if name == 'g_memory_block' && g.pref != unsafe { nil } && g.pref.prealloc {
+			g.sb.writeln('extern _Thread_local ${typ} ${name};')
+		} else {
+			g.sb.writeln('extern ${typ} ${name};')
+		}
 	}
 }
 

vlib/v2/gen/cleanc/expr.v

@@ -3128,7 +3128,10 @@ fn (g &Gen) eval_comptime_flag(name string) bool {
 		'tinyc' {
 			return g.pref != unsafe { nil } && (g.pref.backend == .arm64 || g.pref.backend == .x64)
 		}
-		'new_int', 'gcboehm', 'prealloc', 'autofree' {
+		'prealloc' {
+			return g.pref != unsafe { nil } && g.pref.prealloc
+		}
+		'new_int', 'gcboehm', 'autofree', 'ppc64' {
 			return false
 		}
 		else {

vlib/v2/gen/cleanc/fn.v

@@ -1457,6 +1457,11 @@ fn (mut g Gen) gen_fn_decl_with_name_ptr(node &ast.FnDecl, fn_name string) {
 		g.sb.writeln('g_main_argc = ___argc;')
 		g.write_indent()
 		g.sb.writeln('g_main_argv = (void*)___argv;')
+		// Prealloc arena initialization (must run before any V allocations)
+		if g.pref != unsafe { nil } && g.pref.prealloc {
+			g.write_indent()
+			g.sb.writeln('prealloc_vinit();')
+		}
 		// GC initialization (translated from Go's runtime GC init)
 		if g.pref != unsafe { nil } && g.pref.gc_mode == .vgc {
 			g.write_indent()
@@ -2131,6 +2136,11 @@ fn (g &Gen) is_simple_addressable(expr ast.Expr) bool {
 
 fn (mut g Gen) gen_addr_of_expr(arg ast.Expr, typ string) {
 	base_arg := if arg is ast.ModifierExpr { arg.expr } else { arg }
+	// nil is a null pointer — emit NULL directly, never wrap in compound literal
+	if base_arg is ast.Ident && base_arg.name == 'nil' {
+		g.sb.write_string('NULL')
+		return
+	}
 	if g.can_take_address(base_arg) {
 		g.sb.write_string('&')
 		g.expr(base_arg)
@@ -2303,6 +2313,19 @@ fn (mut g Gen) gen_call_arg(fn_name string, idx int, arg ast.Expr) {
 			return
 		}
 	}
+	// nil is always a valid pointer value (NULL) — never wrap it
+	if (base_arg is ast.Ident && base_arg.name == 'nil') || base_arg is ast.Type {
+		if ptr_params := g.fn_param_is_ptr[fn_name] {
+			if idx < ptr_params.len && ptr_params[idx] {
+				g.sb.write_string('NULL')
+				return
+			}
+		}
+		if base_arg is ast.Ident && base_arg.name == 'nil' {
+			g.sb.write_string('NULL')
+			return
+		}
+	}
 	if fn_name == 'new_map_init_noscan_value' && idx in [7, 8] {
 		// new_map_init_noscan_value expects raw key/value element pointers.
 		// Lowered dynamic arrays arrive as `array` values; pass their `.data`.
@@ -3592,6 +3615,11 @@ fn (mut g Gen) call_expr(lhs ast.Expr, args []ast.Expr) {
 		// Handle C.puts, C.putchar etc.
 		if lhs.lhs is ast.Ident && lhs.lhs.name == 'C' {
 			name = lhs.rhs.name
+			// With prealloc, free() is redefined as a no-op macro.
+			// C.free calls in prealloc_vcleanup need the real free via _v_cfree.
+			if name == 'free' && g.pref != unsafe { nil } && g.pref.prealloc {
+				name = '_v_cfree'
+			}
 			g.sb.write_string('${name}(')
 			for i in 0 .. args.len {
 				arg := args[i]

vlib/v2/pref/pref.v

@@ -50,6 +50,7 @@ pub mut:
 	is_shared_lib         bool                  // Compile to shared library (.dylib/.so) for live reload
 	no_optimize           bool                  // -O0: skip SSA optimization (mem2reg, phi elimination)
 	is_prod               bool                  // -prod: use -O3 optimization for C compiler
+	prealloc              bool                  // -prealloc: use arena allocation (bump-pointer, not thread-safe)
 	gc_mode               GarbageCollectionMode // Garbage collection mode (-gc flag)
 	backend               Backend
 	arch                  Arch = .auto
@@ -290,7 +291,7 @@ pub fn new_preferences_from_args(args []string) Preferences {
 		'-nomarkused', '--nomarkused', '-showcc', '--showcc', '-stats', '--stats',
 		'-print-parsed-files', '--print-parsed-files', '-keepc', '--profile-alloc', '-profile-alloc',
 		'-enable-globals', '--enable-globals', '-shared', '--shared', '-O0', '--single-backend',
-		'-single-backend', '-prod']
+		'-single-backend', '-prod', '-prealloc']
 	for opt in options {
 		if opt !in known_flags_with_values && opt !in known_boolean_flags {
 			eprintln('error: unknown flag `${opt}`')
@@ -308,6 +309,7 @@ pub fn new_preferences_from_args(args []string) Preferences {
 			eprintln('  -d <name>              Define a comptime flag')
 			eprintln('  -enable-globals        Accepted for v1 compatibility')
 			eprintln('  -prod                  Production build: optimize with -O3 -flto')
+			eprintln('  -prealloc              Use arena allocation (faster, not thread-safe)')
 			eprintln('  -O0                    Skip SSA optimization (faster compile, slower code)')
 			eprintln('  --debug                Enable debug mode')
 			eprintln('  -v, --verbose          Enable verbose output')
@@ -338,6 +340,7 @@ pub fn new_preferences_from_args(args []string) Preferences {
 		is_shared_lib:         '-shared' in options || '--shared' in options
 		no_optimize:           '-O0' in options
 		is_prod:               '-prod' in options
+		prealloc:              '-prealloc' in options
 		single_backend:        '--single-backend' in options || '-single-backend' in options
 		gc_mode:               gc_mode
 		backend:               backend
@@ -395,6 +398,7 @@ pub fn new_preferences_using_options(options []string) Preferences {
 		is_shared_lib:         '-shared' in options || '--shared' in options
 		no_optimize:           '-O0' in options
 		is_prod:               '-prod' in options
+		prealloc:              '-prealloc' in options
 		single_backend:        '--single-backend' in options || '-single-backend' in options
 		backend:               backend
 		arch:                  arch

vlib/v2/transformer/if.v

@@ -1172,8 +1172,11 @@ fn (t &Transformer) eval_comptime_flag(name string) bool {
 			// guards select the software fallback path instead of inline asm.
 			return t.pref != unsafe { nil } && (t.pref.backend == .arm64 || t.pref.backend == .x64)
 		}
+		'prealloc' {
+			return t.pref != unsafe { nil } && t.pref.prealloc
+		}
 		// Feature flags that are typically false
-		'new_int', 'gcboehm', 'prealloc', 'autofree' {
+		'new_int', 'gcboehm', 'autofree', 'ppc64' {
 			return false
 		}
 		else {

vlib/v2/types/checker.v

@@ -3078,7 +3078,10 @@ fn (c &Checker) eval_comptime_flag(name string) bool {
 		'builtin_write_buf_to_fd_should_use_c_write' {
 			return c.pref != unsafe { nil } && (c.pref.backend == .arm64 || c.pref.backend == .x64)
 		}
-		'new_int', 'gcboehm', 'prealloc', 'autofree' {
+		'prealloc' {
+			return c.pref != unsafe { nil } && c.pref.prealloc
+		}
+		'new_int', 'gcboehm', 'autofree', 'ppc64' {
 			return false
 		}
 		else {