X-Git-Url: http://nitlanguage.org diff --git a/src/separate_erasure_compiler.nit b/src/separate_erasure_compiler.nit index 304af71..a5d353d 100644 --- a/src/separate_erasure_compiler.nit +++ b/src/separate_erasure_compiler.nit @@ -32,15 +32,16 @@ redef class ToolContext end redef class ModelBuilder - fun run_separate_erasure_compiler(mainmodule: MModule, runtime_type_analysis: RapidTypeAnalysis) + fun run_separate_erasure_compiler(mainmodule: MModule, runtime_type_analysis: nullable RapidTypeAnalysis) do var time0 = get_time - self.toolcontext.info("*** COMPILING TO C ***", 1) + self.toolcontext.info("*** GENERATING C ***", 1) var compiler = new SeparateErasureCompiler(mainmodule, self, runtime_type_analysis) compiler.compile_header # compile class structures + self.toolcontext.info("Property coloring", 2) compiler.new_file("{mainmodule.name}.tables") compiler.do_property_coloring for m in mainmodule.in_importation.greaters do @@ -56,12 +57,15 @@ redef class ModelBuilder # compile methods for m in mainmodule.in_importation.greaters do + self.toolcontext.info("Generate C for module {m}", 2) compiler.new_file("{m.name}.sep") compiler.compile_module_to_c(m) end compiler.display_stats + var time1 = get_time + self.toolcontext.info("*** END GENERATING C: {time1-time0} ***", 2) write_and_make(compiler) end end @@ -72,27 +76,42 @@ class SeparateErasureCompiler private var class_layout: nullable Layout[MClass] protected var vt_layout: nullable Layout[MVirtualTypeProp] - init(mainmodule: MModule, mmbuilder: ModelBuilder, runtime_type_analysis: RapidTypeAnalysis) do + init(mainmodule: MModule, mmbuilder: ModelBuilder, runtime_type_analysis: nullable RapidTypeAnalysis) do super var mclasses = new HashSet[MClass].from(mmbuilder.model.mclasses) var layout_builder: TypingLayoutBuilder[MClass] + var class_colorer = new MClassColorer(mainmodule) if modelbuilder.toolcontext.opt_phmod_typing.value then layout_builder = new MClassHasher(new PHModOperator, mainmodule) + class_colorer.build_layout(mclasses) else if modelbuilder.toolcontext.opt_phand_typing.value then layout_builder = new MClassHasher(new PHAndOperator, mainmodule) + class_colorer.build_layout(mclasses) else if modelbuilder.toolcontext.opt_bm_typing.value then layout_builder = new MClassBMizer(mainmodule) + class_colorer.build_layout(mclasses) else - layout_builder = new MClassColorer(mainmodule) + layout_builder = class_colorer end self.class_layout = layout_builder.build_layout(mclasses) self.class_tables = self.build_class_typing_tables(mclasses) + # lookup vt to build layout with + var vts = new HashMap[MClass, Set[MVirtualTypeProp]] + for mclass in mclasses do + vts[mclass] = new HashSet[MVirtualTypeProp] + for mprop in self.mainmodule.properties(mclass) do + if mprop isa MVirtualTypeProp then + vts[mclass].add(mprop) + end + end + end + # vt coloration - var vt_coloring = new MVirtualTypePropColorer(mainmodule) - var vt_layout = vt_coloring.build_layout(mclasses) + var vt_coloring = new MPropertyColorer[MVirtualTypeProp](mainmodule, class_colorer) + var vt_layout = vt_coloring.build_layout(vts) self.vt_tables = build_vt_tables(mclasses, vt_layout) self.vt_layout = vt_layout end @@ -102,9 +121,13 @@ class SeparateErasureCompiler for mclass in mclasses do var table = new Array[nullable MPropDef] # first, fill table from parents by reverse linearization order - var parents = self.mainmodule.super_mclasses(mclass) - var lin = self.mainmodule.reverse_linearize_mclasses(parents) - for parent in lin do + var parents = new Array[MClass] + if mainmodule.flatten_mclass_hierarchy.has(mclass) then + parents = mclass.in_hierarchy(mainmodule).greaters.to_a + self.mainmodule.linearize_mclasses(parents) + end + for parent in parents do + if parent == mclass then continue for mproperty in self.mainmodule.properties(parent) do if not mproperty isa MVirtualTypeProp then continue var color = layout.pos[mproperty] @@ -147,9 +170,10 @@ class SeparateErasureCompiler var layout = self.class_layout for mclass in mclasses do var table = new Array[nullable MClass] - var supers = new HashSet[MClass] - supers.add_all(self.mainmodule.super_mclasses(mclass)) - supers.add(mclass) + var supers = new Array[MClass] + if mainmodule.flatten_mclass_hierarchy.has(mclass) then + supers = mclass.in_hierarchy(mainmodule).greaters.to_a + end for sup in supers do var color: Int if layout isa PHLayout[MClass, MClass] then @@ -268,7 +292,7 @@ class SeparateErasureCompiler self.header.add_decl("val* BOX_{c_name}({mtype.ctype});") v.add_decl("/* allocate {mtype} */") v.add_decl("val* BOX_{mtype.c_name}({mtype.ctype} value) \{") - v.add("struct instance_{c_name}*res = GC_MALLOC(sizeof(struct instance_{c_name}));") + v.add("struct instance_{c_name}*res = nit_alloc(sizeof(struct instance_{c_name}));") v.require_declaration("class_{c_name}") v.add("res->class = &class_{c_name};") v.add("res->value = value;") @@ -289,7 +313,7 @@ class SeparateErasureCompiler var res = v.new_named_var(mtype, "self") res.is_exact = true var mtype_elt = mtype.arguments.first - v.add("{res} = GC_MALLOC(sizeof(struct instance_{c_name}) + length*sizeof({mtype_elt.ctype}));") + v.add("{res} = nit_alloc(sizeof(struct instance_{c_name}) + length*sizeof({mtype_elt.ctype}));") v.require_declaration("class_{c_name}") v.add("{res}->class = &class_{c_name};") v.add("return {res};") @@ -303,14 +327,12 @@ class SeparateErasureCompiler v.add_decl("{mtype.ctype} NEW_{c_name}(void) \{") var res = v.new_named_var(mtype, "self") res.is_exact = true - v.add("{res} = GC_MALLOC(sizeof(struct instance) + {attrs.length}*sizeof(nitattribute_t));") + v.add("{res} = nit_alloc(sizeof(struct instance) + {attrs.length}*sizeof(nitattribute_t));") v.require_declaration("class_{c_name}") v.add("{res}->class = &class_{c_name};") self.generate_init_attr(v, res, mtype) v.add("return {res};") v.add("\}") - - generate_check_init_instance(mtype) end private fun build_class_vts_table(mclass: MClass): Bool do @@ -580,7 +602,6 @@ class SeparateErasureCompilerVisitor end var length = self.int_instance(array.length) self.send(self.get_property("with_native", arraytype), [res, nat, length]) - self.check_init_instance(res, arraytype) self.add("\}") return res end