v3: speed up cgen x8

Author: medvednikov

vlib/v3/gen/c/cleanc.v

@@ -43,6 +43,7 @@ mut:
 	modules                 map[string]string // alias -> full module name
 	fn_ptr_types            map[string]string // fn_ptr:ret|params -> typedef name
 	fn_decl_param_types     map[string][]types.Type
+	fn_decl_ret_types       map[string]types.Type // fn decl name (and qualified variants) -> return type
 	struct_decl_infos       map[string]StructDeclInfo
 	struct_decl_short_infos map[string]StructDeclInfo
 	runtime_inits           []string
@@ -60,6 +61,7 @@ mut:
 	emitted_optional_types  map[string]bool
 	emitted_fns             map[string]bool
 	array_method_cache      map[string]string
+	param_types_cache       map[string][]types.Type // (name|fallback) -> resolved param types
 	spawn_wrapper_names     map[string]string
 	spawn_wrapper_defs      []string
 	parallel_used           bool
@@ -104,6 +106,7 @@ pub fn FlatGen.new() FlatGen {
 		modules:                 map[string]string{}
 		fn_ptr_types:            map[string]string{}
 		fn_decl_param_types:     map[string][]types.Type{}
+		fn_decl_ret_types:       map[string]types.Type{}
 		struct_decl_infos:       map[string]StructDeclInfo{}
 		struct_decl_short_infos: map[string]StructDeclInfo{}
 		cur_param_names:         []string{}
@@ -113,6 +116,7 @@ pub fn FlatGen.new() FlatGen {
 		emitted_optional_types:  map[string]bool{}
 		emitted_fns:             map[string]bool{}
 		array_method_cache:      map[string]string{}
+		param_types_cache:       map[string][]types.Type{}
 		spawn_wrapper_names:     map[string]string{}
 		spawn_wrapper_defs:      []string{}
 		str_lits:                []string{}
@@ -171,6 +175,7 @@ pub fn (mut g FlatGen) gen_with_used_options(a &flat.FlatAst, used_fns map[strin
 	g.modules = map[string]string{}
 	g.fn_ptr_types = map[string]string{}
 	g.fn_decl_param_types = map[string][]types.Type{}
+	g.fn_decl_ret_types = map[string]types.Type{}
 	g.struct_decl_infos = map[string]StructDeclInfo{}
 	g.struct_decl_short_infos = map[string]StructDeclInfo{}
 	g.cur_param_names = []string{}
@@ -180,6 +185,7 @@ pub fn (mut g FlatGen) gen_with_used_options(a &flat.FlatAst, used_fns map[strin
 	g.emitted_optional_types = map[string]bool{}
 	g.emitted_fns = map[string]bool{}
 	g.array_method_cache = map[string]string{}
+	g.param_types_cache = map[string][]types.Type{}
 	g.spawn_wrapper_names = map[string]string{}
 	g.spawn_wrapper_defs = []string{}
 	g.parallel_used = false
@@ -284,6 +290,7 @@ fn (mut g FlatGen) collect_gen_info() {
 			}
 			ptypes = g.fn_param_types_with_implicit_veb_ctx(node, ptypes)
 			g.register_fn_decl_param_types(node.value, full_name, ptypes)
+			g.register_fn_decl_ret_type(node.value, full_name, node.typ)
 			// Module-level `init()` functions run once at startup. Collect their C
 			// names so _vinit can invoke them (V semantics).
 			if node.value == 'init' && ptypes.len == 0 {
@@ -708,6 +715,29 @@ fn (mut g FlatGen) register_fn_decl_param_types(name string, full_name string, p
 	}
 }
 
+// register_fn_decl_ret_type indexes a fn decl's return type by its name (and qualified
+// variants), so the return type can be looked up in O(1) instead of scanning all AST
+// nodes per call (see fn_decl_return_type_for_call_name).
+fn (mut g FlatGen) register_fn_decl_ret_type(name string, full_name string, ret_typ string) {
+	rt := g.tc.parse_type(ret_typ)
+	if name !in g.fn_decl_ret_types {
+		g.fn_decl_ret_types[name] = rt
+	}
+	if g.tc.cur_module.len > 0 && g.tc.cur_module != 'main' && g.tc.cur_module != 'builtin' {
+		dotted_name := '${g.tc.cur_module}.${name}'
+		if dotted_name !in g.fn_decl_ret_types {
+			g.fn_decl_ret_types[dotted_name] = rt
+		}
+	}
+	if full_name !in g.fn_decl_ret_types {
+		g.fn_decl_ret_types[full_name] = rt
+	}
+	cname := c_name(name)
+	if cname != name && cname !in g.fn_decl_ret_types {
+		g.fn_decl_ret_types[cname] = rt
+	}
+}
+
 // register_struct_decl_info updates register struct decl info state for c.
 fn (mut g FlatGen) register_struct_decl_info(name string, full_name string, module_name string, node flat.Node) {
 	info := StructDeclInfo{

vlib/v3/gen/c/fn.v

@@ -2000,7 +2000,21 @@ fn (g &FlatGen) normalize_call_key(name string) string {
 }
 
 // param_types_for supports param types for handling for FlatGen.
+// param_types_for resolves the parameter types of a called function. It is invoked once
+// per call site during codegen, and the slow path below scans every known function, so
+// results are memoized: without this, generic/monomorphized call names that miss the
+// direct lookups re-scan (and copy) the whole function table on every call (O(n^2)).
 fn (mut g FlatGen) param_types_for(name string, fallback string) []types.Type {
+	cache_key := '${name}\x01${fallback}'
+	if cached := g.param_types_cache[cache_key] {
+		return cached
+	}
+	result := g.param_types_for_uncached(name, fallback)
+	g.param_types_cache[cache_key] = result
+	return result
+}
+
+fn (mut g FlatGen) param_types_for_uncached(name string, fallback string) []types.Type {
 	if name in ['json2.LinkedList[ValueInfo].push', 'json2.LinkedList_ValueInfo.push'] {
 		return [
 			g.tc.parse_type('&json2.LinkedList[ValueInfo]'),
@@ -2031,14 +2045,17 @@ fn (mut g FlatGen) param_types_for(name string, fallback string) []types.Type {
 	}
 	if name.contains('.') {
 		short_name := name.all_after_last('.')
-		for candidate, ptypes in g.fn_decl_param_types {
-			if candidate.ends_with('.${short_name}') {
-				return ptypes
+		suffix := '.${short_name}'
+		// Look up the value only on a match: `for _, v in map` copies every array value
+		// on every iteration, which is wasteful for a table-wide scan.
+		for candidate, _ in g.fn_decl_param_types {
+			if candidate.ends_with(suffix) {
+				return g.fn_decl_param_types[candidate]
 			}
 		}
-		for candidate, ptypes in g.tc.fn_param_types {
-			if candidate.ends_with('.${short_name}') {
-				return ptypes
+		for candidate, _ in g.tc.fn_param_types {
+			if candidate.ends_with(suffix) {
+				return g.tc.fn_param_types[candidate]
 			}
 		}
 	}

vlib/v3/gen/c/fn_d_parallel.v

@@ -354,6 +354,7 @@ fn (g &FlatGen) new_parallel_worker(worker_id int) &FlatGen {
 		modules:                 g.modules.clone()
 		fn_ptr_types:            g.fn_ptr_types.clone()
 		fn_decl_param_types:     g.fn_decl_param_types.clone()
+		fn_decl_ret_types:       g.fn_decl_ret_types.clone()
 		struct_decl_infos:       g.struct_decl_infos.clone()
 		struct_decl_short_infos: g.struct_decl_short_infos.clone()
 		runtime_inits:           g.runtime_inits.clone()
@@ -370,6 +371,7 @@ fn (g &FlatGen) new_parallel_worker(worker_id int) &FlatGen {
 		emitted_optional_types:  g.emitted_optional_types.clone()
 		emitted_fns:             g.emitted_fns.clone()
 		array_method_cache:      g.array_method_cache.clone()
+		param_types_cache:       g.param_types_cache.clone()
 	}
 }
 

vlib/v3/gen/c/names.v

@@ -2,10 +2,45 @@ module c
 
 import strings
 
-const c_reserved_words = ['auto', 'break', 'case', 'char', 'const', 'continue', 'copy', 'default',
-	'do', 'double', 'else', 'enum', 'extern', 'float', 'for', 'goto', 'if', 'inline', 'int', 'long',
-	'register', 'restrict', 'return', 'short', 'signed', 'sizeof', 'static', 'struct', 'switch',
-	'typedef', 'union', 'unsigned', 'void', 'volatile', 'while']
+// c_reserved_words is a set (not a list) so `name in c_reserved_words` is an O(1) hash
+// lookup. c_name() runs on every emitted identifier, so a linear scan here is costly.
+const c_reserved_words = {
+	'auto':     true
+	'break':    true
+	'case':     true
+	'char':     true
+	'const':    true
+	'continue': true
+	'copy':     true
+	'default':  true
+	'do':       true
+	'double':   true
+	'else':     true
+	'enum':     true
+	'extern':   true
+	'float':    true
+	'for':      true
+	'goto':     true
+	'if':       true
+	'inline':   true
+	'int':      true
+	'long':     true
+	'register': true
+	'restrict': true
+	'return':   true
+	'short':    true
+	'signed':   true
+	'sizeof':   true
+	'static':   true
+	'struct':   true
+	'switch':   true
+	'typedef':  true
+	'union':    true
+	'unsigned': true
+	'void':     true
+	'volatile': true
+	'while':    true
+}
 
 // c_name converts c name data for c.
 fn c_name(name string) string {

vlib/v3/gen/c/stmt.v

@@ -673,13 +673,15 @@ fn (g &FlatGen) fn_decl_return_type_for_call_name(name string) ?types.Type {
 	if name.len == 0 {
 		return none
 	}
+	// Indexed in collect_gen_info (register_fn_decl_ret_type); previously this scanned
+	// every AST node per call (O(n^2)) and re-mangled each decl name with c_name.
+	if rt := g.fn_decl_ret_types[name] {
+		return rt
+	}
 	cname := c_name(name)
-	for node in g.a.nodes {
-		if node.kind != .fn_decl && node.kind != .c_fn_decl {
-			continue
-		}
-		if node.value == name || c_name(node.value) == cname {
-			return g.tc.parse_type(node.typ)
+	if cname != name {
+		if rt := g.fn_decl_ret_types[cname] {
+			return rt
 		}
 	}
 	return none