X-Git-Url: http://nitlanguage.org diff --git a/src/compiler/separate_compiler.nit b/src/compiler/separate_compiler.nit index e611f3d..3e7fbcb 100644 --- a/src/compiler/separate_compiler.nit +++ b/src/compiler/separate_compiler.nit @@ -59,6 +59,8 @@ redef class ToolContext var opt_colo_dead_methods = new OptionBool("Force colorization of dead methods", "--colo-dead-methods") # --tables-metrics var opt_tables_metrics = new OptionBool("Enable static size measuring of tables used for vft, typing and resolution", "--tables-metrics") + # --type-poset + var opt_type_poset = new OptionBool("Build a poset of types to create more condensed tables.", "--type-poset") redef init do @@ -72,6 +74,7 @@ redef class ToolContext self.option_context.add_option(self.opt_inline_coloring_numbers, opt_inline_some_methods, opt_direct_call_monomorph, opt_skip_dead_methods, opt_semi_global) self.option_context.add_option(self.opt_colo_dead_methods) self.option_context.add_option(self.opt_tables_metrics) + self.option_context.add_option(self.opt_type_poset) end redef fun process_options(args) @@ -266,7 +269,7 @@ class SeparateCompiler if mclass.mclass_type.ctype_extern == "val*" then return 0 else if mclass.kind == extern_kind and mclass.name != "NativeString" then - return self.box_kinds[self.mainmodule.get_primitive_class("Pointer")] + return self.box_kinds[self.mainmodule.pointer_type.mclass] else return self.box_kinds[mclass] end @@ -383,7 +386,7 @@ class SeparateCompiler method_tables = new HashMap[MClass, Array[nullable MPropDef]] attr_tables = new HashMap[MClass, Array[nullable MProperty]] for mclass in mclasses do - #if mclass.kind == abstract_kind or mclass.kind == interface_kind then continue + if not mclass.has_new_factory and (mclass.kind == abstract_kind or mclass.kind == interface_kind) then continue if rta != null and not rta.live_classes.has(mclass) then continue var mtype = mclass.intro.bound_mtype @@ -414,23 +417,36 @@ class SeparateCompiler end # colorize live types of the program - private fun do_type_coloring: POSet[MType] do + private fun do_type_coloring: Collection[MType] do # Collect types to colorize var live_types = runtime_type_analysis.live_types var live_cast_types = runtime_type_analysis.live_cast_types - # Compute colors - var poset = poset_from_mtypes(live_types, live_cast_types) - var colorer = new POSetColorer[MType] - colorer.colorize(poset) - type_ids = colorer.ids - type_colors = colorer.colors - type_tables = build_type_tables(poset) + var res = new HashSet[MType] + res.add_all live_types + res.add_all live_cast_types + + if modelbuilder.toolcontext.opt_type_poset.value then + # Compute colors with a type poset + var poset = poset_from_mtypes(live_types, live_cast_types) + var colorer = new POSetColorer[MType] + colorer.colorize(poset) + type_ids = colorer.ids + type_colors = colorer.colors + type_tables = build_type_tables(poset) + else + # Compute colors using the class poset + # Faster to compute but the number of holes can degenerate + compute_type_test_layouts(live_types, live_cast_types) + + type_ids = new HashMap[MType, Int] + for x in res do type_ids[x] = type_ids.length + 1 + end # VT and FT are stored with other unresolved types in the big resolution_tables self.compute_resolution_tables(live_types) - return poset + return res end private fun poset_from_mtypes(mtypes, cast_types: Set[MType]): POSet[MType] do @@ -442,14 +458,14 @@ class SeparateCompiler var mtypes_by_class = new MultiHashMap[MClass, MType] for e in mtypes do - var c = e.as_notnullable.as(MClassType).mclass + var c = e.undecorate.as(MClassType).mclass mtypes_by_class[c].add(e) poset.add_node(e) end var casttypes_by_class = new MultiHashMap[MClass, MType] for e in cast_types do - var c = e.as_notnullable.as(MClassType).mclass + var c = e.undecorate.as(MClassType).mclass casttypes_by_class[c].add(e) poset.add_node(e) end @@ -489,6 +505,48 @@ class SeparateCompiler return tables end + + private fun compute_type_test_layouts(mtypes: Set[MClassType], cast_types: Set[MType]) do + # Group cast_type by their classes + var bucklets = new HashMap[MClass, Set[MType]] + for e in cast_types do + var c = e.undecorate.as(MClassType).mclass + if not bucklets.has_key(c) then + bucklets[c] = new HashSet[MType] + end + bucklets[c].add(e) + end + + # Colorize cast_types from the class hierarchy + var colorer = new POSetGroupColorer[MClass, MType](class_conflict_graph, bucklets) + type_colors = colorer.colors + + var layouts = new HashMap[MClass, Array[nullable MType]] + for c in runtime_type_analysis.live_classes do + layouts[c] = colorer.build_layout(c) + end + + # Build the table for each live type + for t in mtypes do + # A live type use the layout of its class + var c = t.mclass + var layout = layouts[c] + var table = new Array[nullable MType].with_capacity(layout.length) + type_tables[t] = table + + # For each potential super-type in the layout + for sup in layout do + if sup == null then + table.add null + else if t.is_subtype(mainmodule, null, sup) then + table.add sup + else + table.add null + end + end + end + end + # resolution_tables is used to perform a type resolution at runtime in O(1) private fun compute_resolution_tables(mtypes: Set[MType]) do # During the visit of the body of classes, live_unresolved_types are collected @@ -684,7 +742,7 @@ class SeparateCompiler # resolution table (for receiver) if is_live then - var mclass_type = mtype.as_notnullable + var mclass_type = mtype.undecorate assert mclass_type isa MClassType if resolution_tables[mclass_type].is_empty then v.add_decl("NULL, /*NO RESOLUTIONS*/") @@ -717,7 +775,7 @@ class SeparateCompiler fun compile_type_resolution_table(mtype: MType) do - var mclass_type = mtype.as_notnullable.as(MClassType) + var mclass_type = mtype.undecorate.as(MClassType) # extern const struct resolution_table_X resolution_table_X self.provide_declaration("resolution_table_{mtype.c_name}", "extern const struct types resolution_table_{mtype.c_name};") @@ -759,7 +817,7 @@ class SeparateCompiler var v = new_visitor var rta = runtime_type_analysis - var is_dead = rta != null and not rta.live_classes.has(mclass) and mtype.ctype == "val*" and mclass.name != "NativeArray" and mclass.name != "Pointer" + var is_dead = rta != null and not rta.live_classes.has(mclass) and not mtype.is_c_primitive and mclass.name != "NativeArray" and mclass.name != "Pointer" v.add_decl("/* runtime class {c_name} */") @@ -789,7 +847,7 @@ class SeparateCompiler v.add_decl("\};") end - if mtype.ctype != "val*" or mtype.mclass.name == "Pointer" then + if mtype.is_c_primitive or mtype.mclass.name == "Pointer" then # Is a primitive type or the Pointer class, not any other extern class if mtype.is_tagged then return @@ -1127,9 +1185,9 @@ class SeparateCompilerVisitor do if value.mtype == mtype then return value - else if value.mtype.ctype == "val*" and mtype.ctype == "val*" then + else if not value.mtype.is_c_primitive and not mtype.is_c_primitive then return value - else if value.mtype.ctype == "val*" then + else if not value.mtype.is_c_primitive then if mtype.is_tagged then if mtype.name == "Int" then return self.new_expr("(long)({value})>>2", mtype) @@ -1142,7 +1200,7 @@ class SeparateCompilerVisitor end end return self.new_expr("((struct instance_{mtype.c_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype) - else if mtype.ctype == "val*" then + else if not mtype.is_c_primitive then if value.mtype.is_tagged then if value.mtype.name == "Int" then return self.new_expr("(val*)({value}<<2|1)", mtype) @@ -1222,7 +1280,7 @@ class SeparateCompilerVisitor # Thus the expression can be used as a condition. fun extract_tag(value: RuntimeVariable): String do - assert value.mtype.ctype == "val*" + assert not value.mtype.is_c_primitive return "((long){value}&3)" # Get the two low bits end @@ -1230,7 +1288,7 @@ class SeparateCompilerVisitor # The point of the method is to work also with primitive types. fun class_info(value: RuntimeVariable): String do - if value.mtype.ctype == "val*" then + if not value.mtype.is_c_primitive then if can_be_primitive(value) and not compiler.modelbuilder.toolcontext.opt_no_tag_primitives.value then var tag = extract_tag(value) return "({tag}?class_info[{tag}]:{value}->class)" @@ -1247,7 +1305,7 @@ class SeparateCompilerVisitor # The point of the method is to work also with primitive types. fun type_info(value: RuntimeVariable): String do - if value.mtype.ctype == "val*" then + if not value.mtype.is_c_primitive then if can_be_primitive(value) and not compiler.modelbuilder.toolcontext.opt_no_tag_primitives.value then var tag = extract_tag(value) return "({tag}?type_info[{tag}]:{value}->type)" @@ -1296,7 +1354,7 @@ class SeparateCompilerVisitor end redef fun send(mmethod, arguments) do - if arguments.first.mcasttype.ctype != "val*" then + if arguments.first.mcasttype.is_c_primitive then # In order to shortcut the primitive, we need to find the most specific method # Howverr, because of performance (no flattening), we always work on the realmainmodule var m = self.compiler.mainmodule @@ -1378,13 +1436,14 @@ class SeparateCompilerVisitor if compiler.modelbuilder.toolcontext.opt_invocation_metrics.value then add("count_invoke_by_tables++;") assert arguments.length == mmethod.intro.msignature.arity + 1 else debug("Invalid arity for {mmethod}. {arguments.length} arguments given.") - var recv = arguments.first var res0 = before_send(mmethod, arguments) var runtime_function = mmethod.intro.virtual_runtime_function var msignature = runtime_function.called_signature + adapt_signature(mmethod.intro, arguments) + var res: nullable RuntimeVariable var ret = msignature.return_mtype if ret == null then @@ -1393,18 +1452,7 @@ class SeparateCompilerVisitor res = self.new_var(ret) end - var ss = new FlatBuffer - - ss.append("{recv}") - for i in [0..msignature.arity[ do - var a = arguments[i+1] - var t = msignature.mparameters[i].mtype - if i == msignature.vararg_rank then - t = arguments[i+1].mcasttype - end - a = self.autobox(a, t) - ss.append(", {a}") - end + var ss = arguments.join(", ") var const_color = mentity.const_color var ress @@ -1503,7 +1551,7 @@ class SeparateCompilerVisitor redef fun supercall(m: MMethodDef, recvtype: MClassType, arguments: Array[RuntimeVariable]): nullable RuntimeVariable do - if arguments.first.mcasttype.ctype != "val*" then + if arguments.first.mcasttype.is_c_primitive then # In order to shortcut the primitive, we need to find the most specific method # However, because of performance (no flattening), we always work on the realmainmodule var main = self.compiler.mainmodule @@ -1554,7 +1602,7 @@ class SeparateCompilerVisitor self.add("{res} = {recv}->attrs[{a.const_color}] != NULL; /* {a} on {recv.inspect}*/") else - if mtype.ctype == "val*" then + if not mtype.is_c_primitive and not mtype.is_tagged then self.add("{res} = {recv}->attrs[{a.const_color}].val != NULL; /* {a} on {recv.inspect} */") else self.add("{res} = 1; /* NOT YET IMPLEMENTED: isset of primitives: {a} on {recv.inspect} */") @@ -1606,7 +1654,7 @@ class SeparateCompilerVisitor self.add("{res} = {recv}->attrs[{a.const_color}].{ret.ctypename}; /* {a} on {recv.inspect} */") # Check for Uninitialized attribute - if ret.ctype == "val*" and not ret isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_attr_isset.value then + if not ret.is_c_primitive and not ret isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_attr_isset.value then self.add("if (unlikely({res} == NULL)) \{") self.add_abort("Uninitialized attribute {a.name}") self.add("\}") @@ -1635,7 +1683,11 @@ class SeparateCompilerVisitor self.require_declaration(a.const_color) if self.compiler.modelbuilder.toolcontext.opt_no_union_attribute.value then var attr = "{recv}->attrs[{a.const_color}]" - if mtype.ctype != "val*" then + if mtype.is_tagged then + # The attribute is not primitive, thus store it as tagged + var tv = autobox(value, compiler.mainmodule.object_type) + self.add("{attr} = {tv}; /* {a} on {recv.inspect} */") + else if mtype.is_c_primitive then assert mtype isa MClassType # The attribute is primitive, thus we store it in a box # The trick is to create the box the first time then resuse the box @@ -1787,15 +1839,15 @@ class SeparateCompilerVisitor do var res = self.new_var(bool_type) # Swap values to be symetric - if value2.mtype.ctype != "val*" and value1.mtype.ctype == "val*" then + if value2.mtype.is_c_primitive and not value1.mtype.is_c_primitive then var tmp = value1 value1 = value2 value2 = tmp end - if value1.mtype.ctype != "val*" then + if value1.mtype.is_c_primitive then if value2.mtype == value1.mtype then self.add("{res} = 1; /* is_same_type_test: compatible types {value1.mtype} vs. {value2.mtype} */") - else if value2.mtype.ctype != "val*" then + else if value2.mtype.is_c_primitive then self.add("{res} = 0; /* is_same_type_test: incompatible types {value1.mtype} vs. {value2.mtype}*/") else var mtype1 = value1.mtype.as(MClassType) @@ -1812,7 +1864,7 @@ class SeparateCompilerVisitor do var res = self.get_name("var_class_name") self.add_decl("const char* {res};") - if value.mtype.ctype == "val*" then + if not value.mtype.is_c_primitive then self.add "{res} = {value} == NULL ? \"null\" : {type_info(value)}->name;" else if value.mtype isa MClassType and value.mtype.as(MClassType).mclass.kind == extern_kind and value.mtype.as(MClassType).name != "NativeString" then @@ -1827,15 +1879,15 @@ class SeparateCompilerVisitor redef fun equal_test(value1, value2) do var res = self.new_var(bool_type) - if value2.mtype.ctype != "val*" and value1.mtype.ctype == "val*" then + if value2.mtype.is_c_primitive and not value1.mtype.is_c_primitive then var tmp = value1 value1 = value2 value2 = tmp end - if value1.mtype.ctype != "val*" then + if value1.mtype.is_c_primitive then if value2.mtype == value1.mtype then self.add("{res} = {value1} == {value2};") - else if value2.mtype.ctype != "val*" then + else if value2.mtype.is_c_primitive then self.add("{res} = 0; /* incompatible types {value1.mtype} vs. {value2.mtype}*/") else if value1.mtype.is_tagged then self.add("{res} = ({value2} != NULL) && ({self.autobox(value2, value1.mtype)} == {value1});") @@ -1868,11 +1920,11 @@ class SeparateCompilerVisitor var incompatible = false var primitive - if t1.ctype != "val*" then + if t1.is_c_primitive then primitive = t1 if t1 == t2 then # No need to compare class - else if t2.ctype != "val*" then + else if t2.is_c_primitive then incompatible = true else if can_be_primitive(value2) then if t1.is_tagged then @@ -1886,7 +1938,7 @@ class SeparateCompilerVisitor else incompatible = true end - else if t2.ctype != "val*" then + else if t2.is_c_primitive then primitive = t2 if can_be_primitive(value1) then if t2.is_tagged then @@ -1944,10 +1996,10 @@ class SeparateCompilerVisitor fun can_be_primitive(value: RuntimeVariable): Bool do - var t = value.mcasttype.as_notnullable + var t = value.mcasttype.undecorate if not t isa MClassType then return false var k = t.mclass.kind - return k == interface_kind or t.ctype != "val*" + return k == interface_kind or t.is_c_primitive end fun maybe_null(value: RuntimeVariable): Bool @@ -1958,8 +2010,8 @@ class SeparateCompilerVisitor redef fun array_instance(array, elttype) do - var nclass = self.get_class("NativeArray") - var arrayclass = self.get_class("Array") + var nclass = mmodule.native_array_class + var arrayclass = mmodule.array_class var arraytype = arrayclass.get_mtype([elttype]) var res = self.init_instance(arraytype) self.add("\{ /* {res} = array_instance Array[{elttype}] */") @@ -1976,7 +2028,7 @@ class SeparateCompilerVisitor redef fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable do - var mtype = self.get_class("NativeArray").get_mtype([elttype]) + var mtype = mmodule.native_array_type(elttype) self.require_declaration("NEW_{mtype.mclass.c_name}") assert mtype isa MGenericType var compiler = self.compiler @@ -1996,7 +2048,7 @@ class SeparateCompilerVisitor redef fun native_array_def(pname, ret_type, arguments) do var elttype = arguments.first.mtype - var nclass = self.get_class("NativeArray") + var nclass = mmodule.native_array_class var recv = "((struct instance_{nclass.c_name}*){arguments[0]})->values" if pname == "[]" then # Because the objects are boxed, return the box to avoid unnecessary (or broken) unboxing/reboxing @@ -2017,12 +2069,20 @@ class SeparateCompilerVisitor end end - redef fun calloc_array(ret_type, arguments) + redef fun native_array_get(nat, i) do - var mclass = self.get_class("ArrayCapable") - var ft = mclass.mparameters.first - var res = self.native_array_instance(ft, arguments[1]) - self.ret(res) + var nclass = mmodule.native_array_class + var recv = "((struct instance_{nclass.c_name}*){nat})->values" + # Because the objects are boxed, return the box to avoid unnecessary (or broken) unboxing/reboxing + var res = self.new_expr("{recv}[{i}]", compiler.mainmodule.object_type) + return res + end + + redef fun native_array_set(nat, i, val) + do + var nclass = mmodule.native_array_class + var recv = "((struct instance_{nclass.c_name}*){nat})->values" + self.add("{recv}[{i}]={val};") end fun link_unresolved_type(mclassdef: MClassDef, mtype: MType) do @@ -2135,7 +2195,7 @@ class SeparateRuntimeFunction for i in [0..called_signature.arity[ do var mtype = called_signature.mparameters[i].mtype if i == called_signature.vararg_rank then - mtype = mmethoddef.mclassdef.mmodule.get_primitive_class("Array").get_mtype([mtype]) + mtype = mmethoddef.mclassdef.mmodule.array_type(mtype) end sig.append(", {mtype.ctype} p{i}") end @@ -2174,7 +2234,7 @@ class SeparateRuntimeFunction for i in [0..msignature.arity[ do var mtype = msignature.mparameters[i].mtype if i == msignature.vararg_rank then - mtype = v.get_class("Array").get_mtype([mtype]) + mtype = v.mmodule.array_type(mtype) end comment.append(", {mtype}") var argvar = new RuntimeVariable("p{i}", mtype, mtype) @@ -2221,14 +2281,14 @@ class SeparateRuntimeFunction var selfvar = arguments.first var ret = called_signature.return_mtype - if mmethoddef.is_intro and recv.ctype == "val*" then + if mmethoddef.is_intro and not recv.is_c_primitive then var m = mmethoddef.mproperty var n2 = "CALL_" + m.const_color compiler.provide_declaration(n2, "{c_ret} {n2}{c_sig};") var v2 = compiler.new_visitor v2.add "{c_ret} {n2}{c_sig} \{" v2.require_declaration(m.const_color) - var call = "(({c_funptrtype})({selfvar}->class->vft[{m.const_color}]))({arguments.join(", ")});" + var call = "(({c_funptrtype})({v2.class_info(selfvar)}->vft[{m.const_color}]))({arguments.join(", ")});" if ret != null then v2.add "return {call}" else @@ -2238,14 +2298,14 @@ class SeparateRuntimeFunction v2.add "\}" end - if mmethoddef.has_supercall and recv.ctype == "val*" then + if mmethoddef.has_supercall and not recv.is_c_primitive then var m = mmethoddef var n2 = "CALL_" + m.const_color compiler.provide_declaration(n2, "{c_ret} {n2}{c_sig};") var v2 = compiler.new_visitor v2.add "{c_ret} {n2}{c_sig} \{" v2.require_declaration(m.const_color) - var call = "(({c_funptrtype})({selfvar}->class->vft[{m.const_color}]))({arguments.join(", ")});" + var call = "(({c_funptrtype})({v2.class_info(selfvar)}->vft[{m.const_color}]))({arguments.join(", ")});" if ret != null then v2.add "return {call}" else @@ -2286,3 +2346,14 @@ redef class AMethPropdef return super end end + +redef class AAttrPropdef + redef fun init_expr(v, recv) + do + super + if is_lazy and v.compiler.modelbuilder.toolcontext.opt_no_union_attribute.value then + var guard = self.mlazypropdef.mproperty + v.write_attribute(guard, recv, v.bool_instance(false)) + end + end +end