X-Git-Url: http://nitlanguage.org diff --git a/src/layout_builders.nit b/src/layout_builders.nit index 029afac..f7dc388 100644 --- a/src/layout_builders.nit +++ b/src/layout_builders.nit @@ -13,12 +13,23 @@ # limitations under the License. # Table layout builders +# Tables are used to implement objects mecanisms like: +# * message sending +# * attribute accessing +# * typing +# * resolution (for generic types) +# This module provides various layout for object tables: +# * coloring +# * binary matrix +# * perfect hashing (and & mod operators) module layout_builders import abstract_compiler # Layouts +# A layout is the result of computation by builders +# it contains necessary informations for basic table creation class Layout[E: Object] # Ids or each element var ids: Map[E, Int] = new HashMap[E, Int] @@ -26,6 +37,8 @@ class Layout[E: Object] var pos: Map[E, Int] = new HashMap[E, Int] end +# A PHLayout is used everywere the builder used perfect hashing +# it adds masks and hashes informations to std layout class PHLayout[HOLDER: Object, E: Object] super Layout[E] # Masks used by hash function @@ -34,44 +47,106 @@ class PHLayout[HOLDER: Object, E: Object] var hashes: Map[HOLDER, Map[E, Int]] = new HashMap[HOLDER, Map[E, Int]] end -class PropertyLayout[E: Object] - # Fixed positions of each element in all tables - var pos: Map[E, Int] = new HashMap[E, Int] -end - # Builders +# TypingLayoutBuilder is used to build a layout for typing tables (by type or by class) interface TypingLayoutBuilder[E: Object] # Build typing table layout + # elements: the set of elements (classes or types) used in typing tables fun build_layout(elements: Set[E]): Layout[E] is abstract + # Get the poset used for table layout construction + # REQUIRE: build_layout + fun poset: nullable POSet[E] is abstract end -interface PropertyLayoutBuilder[E: MProperty] +# Layout builder dedicated to vft, attribute & VT tables +interface PropertyLayoutBuilder[E: PropertyLayoutElement] # Build table layout for attributes, methods and virtual types - fun build_layout(elements: Set[MClass]): Layout[E] is abstract + # elements: the associative map between classes and properties to use in table layout + fun build_layout(elements: Map[MClass, Set[E]]): Layout[E] is abstract +end + +# Used to create a common ancestors to MProperty and MPropDef +# Required for polymorphic calls +# FIXME: there should be a better way +interface PropertyLayoutElement end + +redef class MProperty + super PropertyLayoutElement +end + +redef class MPropDef + super PropertyLayoutElement end +# For resolution tables (generics) interface ResolutionLayoutBuilder # Build resolution table layout + # elements: association between classes and resolved types fun build_layout(elements: Map[MClassType, Set[MType]]): Layout[MType] is abstract end +# POSet builders + +# A POSet builder build a poset for a set of MType or MClass +# the resulting poset is used by the layout builders +private abstract class POSetBuilder[E: Object] + private var mmodule: MModule + init(mmodule: MModule) do self.mmodule = mmodule + # Build the poset from `elements` + private fun build_poset(elements: Set[E]): POSet[E] is abstract +end + +# A TypingLayoutBuilder used for MType based typing +# such as in separate compilers +private class MTypePOSetBuilder + super POSetBuilder[MType] + redef fun build_poset(elements) do + var poset = new POSet[MType] + for e in elements do + poset.add_node(e) + for o in elements do + if e == o then continue + if e.is_subtype(mmodule, null, o) then + poset.add_edge(e, o) + end + end + end + return poset + end +end + +# A TypingLayoutBuilder used for MClass based typing +# such as in erased compilers or used in property coloring +private class MClassPOSetBuilder + super POSetBuilder[MClass] + redef fun build_poset(elements) do return mmodule.flatten_mclass_hierarchy +end + # Matrice computers +# Abstract layout builder for resolution tables using Binary Matrix (BM) abstract class TypingBMizer[E: Object] super TypingLayoutBuilder[E] - var mmodule: MModule + private var mmodule: MModule + private var poset_builder: POSetBuilder[E] + private var poset_cache: nullable POSet[E] - init(mmodule: MModule) do + private init(mmodule: MModule, poset_builder: POSetBuilder[E]) do self.mmodule = mmodule + self.poset_builder = poset_builder end + redef fun poset do return poset_cache + # Compute mtypes ids and position using BM redef fun build_layout(elements: Set[E]): Layout[E] do var result = new Layout[E] var ids = new HashMap[E, Int] - var lin = self.reverse_linearize(elements) + poset_cache = poset_builder.build_poset(elements) + var lin = poset.to_a + poset.sort(lin) for element in lin do ids[element] = ids.length end @@ -79,28 +154,18 @@ abstract class TypingBMizer[E: Object] result.pos = ids return result end - - private fun reverse_linearize(elements: Set[E]): Array[E] is abstract end +# Layout builder for typing tables based on classes using Binary Matrix (BM) class MTypeBMizer super TypingBMizer[MType] - - init(mmodule: MModule) do super(mmodule) - - redef fun reverse_linearize(elements) do - return self.mmodule.reverse_linearize_mtypes(elements) - end + init(mmodule: MModule) do super(mmodule, new MTypePOSetBuilder(mmodule)) end +# Layout builder for typing tables based on types using Binary Matrix (BM) class MClassBMizer super TypingBMizer[MClass] - - init(mmodule: MModule) do super(mmodule) - - redef fun reverse_linearize(elements) do - return self.mmodule.reverse_linearize_mclasses(elements) - end + init(mmodule: MModule) do super(mmodule, new MClassPOSetBuilder(mmodule)) end # Layout builder for resolution tables using Binary Matrix (BM) @@ -126,21 +191,56 @@ class ResolutionBMizer end end +# Abstract Layout builder for mproperties using Binary Matrix (BM) +class MPropertyBMizer[E: PropertyLayoutElement] + super PropertyLayoutBuilder[E] + + var mmodule: MModule + + init(mmodule: MModule) do self.mmodule = mmodule + + redef fun build_layout(elements) do + var result = new Layout[E] + var ids = new HashMap[E, Int] + var lin = new Array[MClass] + lin.add_all(elements.keys) + self.mmodule.linearize_mclasses(lin) + for mclass in lin do + for mproperty in elements[mclass] do + if ids.has_key(mproperty) then continue + ids[mproperty] = ids.length + end + end + result.pos = ids + return result + end +end + # Colorers +# Abstract Layout builder for typing table using coloration (CL) abstract class TypingColorer[E: Object] super TypingLayoutBuilder[E] private var core: Set[E] = new HashSet[E] private var crown: Set[E] = new HashSet[E] private var border: Set[E] = new HashSet[E] - private var coloration_result: Map[E, Int] = new HashMap[E, Int] - init do end + private var mmodule: MModule + private var poset_builder: POSetBuilder[E] + private var poset_cache: nullable POSet[E] + + private init(mmodule: MModule, poset_builder: POSetBuilder[E]) do + self.mmodule = mmodule + self.poset_builder = poset_builder + end + + redef fun poset do return poset_cache # Compute the layout with coloring redef fun build_layout(elements: Set[E]): Layout[E] do + poset_cache = poset_builder.build_poset(elements) var result = new Layout[E] result.ids = compute_ids(elements) result.pos = colorize(elements) @@ -149,8 +249,7 @@ abstract class TypingColorer[E: Object] private fun compute_ids(elements: Set[E]): Map[E, Int] do var ids = new HashMap[E, Int] - var lin = reverse_linearize(elements) - for element in lin do + for element in reverse_linearize(elements) do ids[element] = ids.length end return ids @@ -158,7 +257,7 @@ abstract class TypingColorer[E: Object] private fun colorize(elements: Set[E]): Map[E, Int] do tag_elements(elements) - build_conflicts_graph(elements) + build_conflicts_graph colorize_elements(core) colorize_elements(border) colorize_elements(crown) @@ -187,7 +286,8 @@ abstract class TypingColorer[E: Object] if coloration_result.has_key(st) and coloration_result[st] == color then return false end end - for st in self.super_elements(element, elements) do + for st in self.poset[element].greaters do + if st == element then continue if coloration_result.has_key(st) and coloration_result[st] == color then return false end return true @@ -198,23 +298,21 @@ abstract class TypingColorer[E: Object] for element in elements do # Check if sub elements are all in single inheritance var all_subelements_si = true - for subelem in self.sub_elements(element, elements) do - if self.is_element_mi(subelem, elements) then + for subelem in self.poset[element].smallers do + if self.poset[subelem].direct_greaters.length > 1 then all_subelements_si = false break end end # Tag as core, crown or border - if self.is_element_mi(element, elements) then - core.add_all(self.super_elements(element, elements)) - core.add(element) + if self.poset[element].direct_greaters.length > 1 then + core.add_all(self.poset[element].greaters) if all_subelements_si then border.add(element) end else if not all_subelements_si then - core.add_all(self.super_elements(element, elements)) - core.add(element) + core.add_all(self.poset[element].greaters) else crown.add(element) end @@ -222,18 +320,18 @@ abstract class TypingColorer[E: Object] end # Conflicts graph of elements hierarchy (two types are in conflict if they have common subelements) - private fun build_conflicts_graph(elements: Set[E]) do + private fun build_conflicts_graph do self.conflicts_graph = new HashMap[E, HashSet[E]] var core = reverse_linearize(self.core) for t in core do - for i in self.linear_extension(t, elements) do + for i in self.linear_extension(t) do if t == i then continue - var lin_i = self.linear_extension(i, elements) + var lin_i = self.linear_extension(i) - for j in self.linear_extension(t, elements) do + for j in self.linear_extension(t) do if i == j or j == t then continue - var lin_j = self.linear_extension(j, elements) + var lin_j = self.linear_extension(j) var d_ij = lin_i - lin_j var d_ji = lin_j - lin_i @@ -259,107 +357,85 @@ abstract class TypingColorer[E: Object] private var linear_extensions_cache: Map[E, Array[E]] = new HashMap[E, Array[E]] # Return a linear_extension of super_elements of the element - private fun linear_extension(element: E, elements: Set[E]): Array[E] do + private fun linear_extension(element: E): Array[E] do if not self.linear_extensions_cache.has_key(element) then var supers = new HashSet[E] - supers.add(element) - supers.add_all(self.super_elements(element, elements)) + supers.add_all(self.poset[element].greaters) self.linear_extensions_cache[element] = self.linearize(supers) end return self.linear_extensions_cache[element] end - private fun super_elements(element: E, elements: Set[E]): Set[E] is abstract - private fun sub_elements(element: E, elements: Set[E]): Set[E] is abstract - private fun is_element_mi(element: E, elements: Set[E]): Bool is abstract - private fun linearize(elements: Set[E]): Array[E] is abstract - private fun reverse_linearize(elements: Set[E]): Array[E] is abstract + private fun reverse_linearize(elements: Set[E]): Array[E] do + var lin = new Array[E] + lin.add_all(elements) + poset.sort(lin) + return lin + end + private fun linearize(elements: Set[E]): Array[E] do return reverse_linearize(elements).reversed end -# MType coloring +# Layout builder for typing tables based on types using coloration (CL) class MTypeColorer super TypingColorer[MType] - - var mmodule: MModule - - init(mmodule: MModule) do self.mmodule = mmodule - - redef fun super_elements(element, elements) do return self.mmodule.super_mtypes(element, elements) - redef fun is_element_mi(element, elements) do return self.super_elements(element, elements).length > 1 - redef fun sub_elements(element, elements) do do return self.mmodule.sub_mtypes(element, elements) - redef fun linearize(elements) do return self.mmodule.linearize_mtypes(elements) - redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mtypes(elements) + init(mmodule: MModule) do super(mmodule, new MTypePOSetBuilder(mmodule)) end -# MClass coloring +# Layout builder for typing tables based on classes using coloration (CL) class MClassColorer super TypingColorer[MClass] - - private var mmodule: MModule - - init(mmodule: MModule) do self.mmodule = mmodule - - redef fun super_elements(element, elements) do return self.mmodule.super_mclasses(element) - fun parent_elements(element: MClass): Set[MClass] do return self.mmodule.parent_mclasses(element) - redef fun is_element_mi(element, elements) do return self.parent_elements(element).length > 1 - redef fun sub_elements(element, elements) do do return self.mmodule.sub_mclasses(element) - redef fun linearize(elements) do return self.mmodule.linearize_mclasses(elements) - redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mclasses(elements) + init(mmodule: MModule) do super(mmodule, new MClassPOSetBuilder(mmodule)) end -# MProperty coloring -abstract class MPropertyColorer[E: MProperty] +# Abstract Layout builder for properties tables using coloration (CL) +class MPropertyColorer[E: PropertyLayoutElement] super PropertyLayoutBuilder[E] private var mmodule: MModule private var class_colorer: MClassColorer private var coloration_result: Map[E, Int] = new HashMap[E, Int] - init(mmodule: MModule) do + init(mmodule: MModule, class_colorer: MClassColorer) do self.mmodule = mmodule - self.class_colorer = new MClassColorer(mmodule) + self.class_colorer = class_colorer end # Compute mclasses ids and position using BM - redef fun build_layout(mclasses: Set[MClass]): Layout[E] do + redef fun build_layout(elements: Map[MClass, Set[E]]): Layout[E] do var result = new Layout[E] - result.pos = self.colorize(mclasses) + result.pos = self.colorize(elements) return result end - private fun colorize(mclasses: Set[MClass]): Map[E, Int] do - self.class_colorer.tag_elements(mclasses) - self.class_colorer.build_conflicts_graph(mclasses) - self.colorize_core(self.class_colorer.core) - self.colorize_crown(self.class_colorer.crown) + private fun colorize(elements: Map[MClass, Set[E]]): Map[E, Int] do + self.colorize_core(elements) + self.colorize_crown(elements) return self.coloration_result end # Colorize properties of the core hierarchy - private fun colorize_core(mclasses: Set[MClass]) do + private fun colorize_core(elements: Map[MClass, Set[E]]) do var min_color = 0 - for mclass in mclasses do + for mclass in self.class_colorer.core do var color = min_color - - # if the class is root, get the minimal color - if self.mmodule.parent_mclasses(mclass).length == 0 then - colorize_elements(self.properties(mclass), color) - else - # check last color used by parents - color = max_color(color, self.mmodule.parent_mclasses(mclass)) - # check max color used in conflicts - if self.class_colorer.conflicts_graph.has_key(mclass) then - color = max_color(color, self.class_colorer.conflicts_graph[mclass]) - end - colorize_elements(self.properties(mclass), color) + # check last color used by parents + color = max_color(color, mclass.in_hierarchy(mmodule).direct_greaters, elements) + # check max color used in conflicts + if self.class_colorer.conflicts_graph.has_key(mclass) then + color = max_color(color, self.class_colorer.conflicts_graph[mclass], elements) end + colorize_elements(elements[mclass], color) end end # Colorize properties of the crown hierarchy - private fun colorize_crown(mclasses: Set[MClass]) do - for mclass in mclasses do - colorize_elements(self.properties(mclass), max_color(0, self.mmodule.parent_mclasses(mclass))) + private fun colorize_crown(elements: Map[MClass, Set[E]]) do + for mclass in self.class_colorer.crown do + var parents = new HashSet[MClass] + if mmodule.flatten_mclass_hierarchy.has(mclass) then + parents.add_all(mclass.in_hierarchy(mmodule).direct_greaters) + end + colorize_elements(elements[mclass], max_color(0, parents, elements)) end end @@ -372,11 +448,11 @@ abstract class MPropertyColorer[E: MProperty] end end - private fun max_color(min_color: Int, mclasses: Collection[MClass]): Int do + private fun max_color(min_color: Int, mclasses: Collection[MClass], elements: Map[MClass, Set[E]]): Int do var max_color = min_color for mclass in mclasses do - for mproperty in self.properties(mclass) do + for mproperty in elements[mclass] do var color = min_color if self.coloration_result.has_key(mproperty) then color = self.coloration_result[mproperty] @@ -386,57 +462,9 @@ abstract class MPropertyColorer[E: MProperty] end return max_color end - - # Filter properties - private fun properties(mclass: MClass): Set[E] is abstract -end - -# Coloring for MMethods -class MMethodColorer - super MPropertyColorer[MMethod] - - init(mmodule: MModule) do super - - redef fun properties(mclass) do - var properties = new HashSet[MMethod] - for mprop in self.mmodule.properties(mclass) do - if mprop isa MMethod then properties.add(mprop) - end - return properties - end -end - -# Coloring for MMAttributes -class MAttributeColorer - super MPropertyColorer[MAttribute] - - init(mmodule: MModule) do super - - redef fun properties(mclass) do - var properties = new HashSet[MAttribute] - for mprop in self.mmodule.properties(mclass) do - if mprop isa MAttribute then properties.add(mprop) - end - return properties - end -end - -# Coloring for MVirtualTypeProps -class MVirtualTypePropColorer - super MPropertyColorer[MVirtualTypeProp] - - init(mmodule: MModule) do super - - redef fun properties(mclass) do - var properties = new HashSet[MVirtualTypeProp] - for mprop in self.mmodule.properties(mclass) do - if mprop isa MVirtualTypeProp then properties.add(mprop) - end - return properties - end end -# Colorer for type resolution table +# Layout builder for resolution tables using coloration (CL) class ResolutionColorer super ResolutionLayoutBuilder @@ -523,8 +551,9 @@ private class PerfectHasher[T: Object, U: Object] var operator: PHOperator - init(operator: PHOperator) do self.operator = operator + init do end + # Compute mask for each holders fun compute_masks(conflicts: Map[T, Set[U]], ids: Map[U, Int]): Map[T, Int] do var masks = new HashMap[T, Int] for mclasstype, mtypes in conflicts do @@ -551,6 +580,7 @@ private class PerfectHasher[T: Object, U: Object] return mask end + # Compute hash for each element in each holder fun compute_hashes(elements: Map[T, Set[U]], ids: Map[U, Int], masks: Map[T, Int]): Map[T, Map[U, Int]] do var hashes = new HashMap[T, Map[U, Int]] for mclasstype, mtypes in elements do @@ -567,6 +597,7 @@ end # Abstract operator used for perfect hashing abstract class PHOperator + # hash `id` using `mask` fun op(mask: Int, id:Int): Int is abstract end @@ -586,30 +617,36 @@ class PHAndOperator redef fun op(mask, id) do return mask.bin_and(id) end +# Layout builder for typing tables using perfect hashing (PH) class TypingHasher[E: Object] super PerfectHasher[E, E] super TypingLayoutBuilder[E] - var mmodule: MModule + private var mmodule: MModule + private var poset_builder: POSetBuilder[E] + private var poset_cache: nullable POSet[E] - init(operator: PHOperator, mmodule: MModule) do - super(operator) + private init(mmodule: MModule, poset_builder: POSetBuilder[E], operator: PHOperator) do + self.operator = operator self.mmodule = mmodule + self.poset_builder = poset_builder end redef fun build_layout(elements: Set[E]): PHLayout[E, E] do + poset_cache = poset_builder.build_poset(elements) var result = new PHLayout[E, E] var conflicts = self.build_conflicts(elements) - result.ids = self.compute_ids(elements) + result.ids = self.compute_ids result.masks = self.compute_masks(conflicts, result.ids) result.hashes = self.compute_hashes(conflicts, result.ids, result.masks) return result end # Ids start from 1 instead of 0 - private fun compute_ids(elements: Set[E]): Map[E, Int] do + private fun compute_ids: Map[E, Int] do var ids = new HashMap[E, Int] - var lin = self.reverse_linearize(elements) + var lin = poset.to_a + poset.sort(lin) for e in lin do ids[e] = ids.length + 1 end @@ -619,56 +656,79 @@ class TypingHasher[E: Object] private fun build_conflicts(elements: Set[E]): Map[E, Set[E]] do var conflicts = new HashMap[E, Set[E]] for e in elements do - var supers = self.super_elements(e, elements) + var supers = new HashSet[E] + supers.add_all(self.poset[e].greaters) supers.add(e) conflicts[e] = supers end return conflicts end - - private fun super_elements(element: E, elements: Set[E]): Set[E] is abstract - private fun reverse_linearize(elements: Set[E]): Array[E] is abstract end +# Layout builder for typing tables with types using perfect hashing (PH) class MTypeHasher super TypingHasher[MType] - - init(operator: PHOperator, mmodule: MModule) do super(operator, mmodule) - - redef fun super_elements(element, elements) do - return self.mmodule.super_mtypes(element, elements) - end - - redef fun reverse_linearize(elements) do - return self.mmodule.reverse_linearize_mtypes(elements) - end + init(operator: PHOperator, mmodule: MModule) do super(mmodule, new MTypePOSetBuilder(mmodule), operator) end +# Layout builder for typing tables with classes using perfect hashing (PH) class MClassHasher super TypingHasher[MClass] + init(operator: PHOperator, mmodule: MModule) do super(mmodule, new MClassPOSetBuilder(mmodule), operator) +end - init(operator: PHOperator, mmodule: MModule) do super(operator, mmodule) +# Abstract layout builder for properties tables using perfect hashing (PH) +class MPropertyHasher[E: PropertyLayoutElement] + super PerfectHasher[MClass, E] + super PropertyLayoutBuilder[E] + + var mmodule: MModule - redef fun super_elements(element, elements) do - return self.mmodule.super_mclasses(element) + init(operator: PHOperator, mmodule: MModule) do + self.operator = operator + self.mmodule = mmodule end - redef fun reverse_linearize(elements) do - return self.mmodule.reverse_linearize_mclasses(elements) + fun build_poset(mclasses: Set[MClass]): POSet[MClass] do + var poset = new POSet[MClass] + for e in mclasses do + poset.add_node(e) + for o in mclasses do + if e == o or not mmodule.flatten_mclass_hierarchy.has(e) then continue + if e.in_hierarchy(mmodule) < o then poset.add_edge(e, o) + end + end + return poset end -end -# Layout builder for MProperty using Perfect Hashing (PH) -# TODO implement this class without sublcassing CL builder -class MPropertyHasher[E: MProperty] - super MPropertyColorer[E] + redef fun build_layout(elements) do + var result = new PHLayout[MClass, E] + var ids = new HashMap[E, Int] + var mclasses = new HashSet[MClass] + mclasses.add_all(elements.keys) + var poset = build_poset(mclasses) + var lin = poset.to_a + poset.sort(lin) + for mclass in lin.reversed do + for mproperty in elements[mclass] do + if ids.has_key(mproperty) then continue + ids[mproperty] = ids.length + 1 + end + end + result.ids = ids + result.pos = ids + result.masks = self.compute_masks(elements, ids) + result.hashes = self.compute_hashes(elements, ids, result.masks) + return result + end end +# Layout builder for resolution tables using perfect hashing (PH) class ResolutionHasher super PerfectHasher[MClassType, MType] super ResolutionLayoutBuilder - init(operator: PHOperator) do super(operator) + init(operator: PHOperator) do self.operator = operator # Compute resolved types masks and hashes redef fun build_layout(elements) do @@ -688,4 +748,4 @@ class ResolutionHasher result.hashes = self.compute_hashes(elements, ids, result.masks) return result end -end \ No newline at end of file +end