# 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]
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
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
-abstract class TypingLayoutBuilder[E: Object]
-
- type LAYOUT: Layout[E]
-
- private var mmodule: MModule
- init(mmodule: MModule) do self.mmodule = mmodule
-
- # Compute elements ids and position
- fun build_layout(elements: Set[E]): LAYOUT is abstract
-
- # Give each MType a unic id using a descending linearization of the `mtypes` set
- private fun compute_ids(elements: Set[E]): Map[E, Int] do
- var ids = new HashMap[E, Int]
- var lin = self.reverse_linearize(elements)
- for element in lin do
- ids[element] = ids.length
- end
- return ids
- end
-
- private fun reverse_linearize(elements: Set[E]): Array[E] is abstract
+# 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
end
-# Layout builder for MType using Binary Matrix (BM)
-class BMTypeLayoutBuilder
- super TypingLayoutBuilder[MType]
-
- init(mmodule: MModule) do super
-
- # Compute mtypes ids and position using BM
- redef fun build_layout(mtypes) do
- var result = new Layout[MType]
- result.ids = self.compute_ids(mtypes)
- result.pos = result.ids
- return result
- end
-
- redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mtypes(elements)
+# Layout builder dedicated to vft, attribute & VT tables
+interface PropertyLayoutBuilder[E: MProperty]
+ # Build table layout for attributes, methods and virtual types
+ # elements: the set of classes containing the properties to use in table layout
+ fun build_layout(elements: Set[MClass]): Layout[E] is abstract
end
-# Layout builder for MType using Coloring (CL)
-class CLTypeLayoutBuilder
- super TypingLayoutBuilder[MType]
-
- private var colorer: MTypeColorer
-
- init(mmodule: MModule) do
- super
- self.colorer = new MTypeColorer(mmodule)
- end
-
- # Compute mtypes ids and position using BM
- redef fun build_layout(mtypes) do
- var result = new Layout[MType]
- result.ids = self.compute_ids(mtypes)
- result.pos = self.colorer.colorize(mtypes)
- return result
- end
-
- redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mtypes(elements)
+# 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
-# Layout builder for MType using Perfect Hashing (PH)
-class PHTypeLayoutBuilder
- super TypingLayoutBuilder[MType]
+# Matrice computers
- redef type LAYOUT: PHLayout[MType, MType]
+# Abstract layout builder for resolution tables using Binary Matrix (BM)
+abstract class TypingBMizer[E: Object]
+ super TypingLayoutBuilder[E]
- private var hasher: PerfectHasher[MType, MType]
-
- init(mmodule: MModule, operator: PHOperator) do
- super(mmodule)
- self.hasher = new PerfectHasher[MType, MType](operator)
- end
+ var mmodule: MModule
- private fun build_conflicts(mtypes: Set[MType]): Map[MType, Set[MType]] do
- var conflicts = new HashMap[MType, Set[MType]]
- for mtype in mtypes do
- var supers = self.mmodule.super_mtypes(mtype, mtypes)
- supers.add(mtype)
- conflicts[mtype] = supers
- end
- return conflicts
+ init(mmodule: MModule) do
+ self.mmodule = mmodule
end
# Compute mtypes ids and position using BM
- redef fun build_layout(mtypes) do
- var result = new PHLayout[MType, MType]
- var conflicts = build_conflicts(mtypes)
- result.ids = self.compute_ids(mtypes)
- result.masks = self.hasher.compute_masks(conflicts, result.ids)
- result.hashes = self.hasher.compute_hashes(conflicts, result.ids, result.masks)
- return result
- end
-
- # Ids start from 1 instead of 0
- redef fun compute_ids(mtypes) do
- var ids = new HashMap[MType, Int]
- var lin = self.mmodule.reverse_linearize_mtypes(mtypes)
- for mtype in lin do
- ids[mtype] = ids.length + 1
+ 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)
+ for element in lin do
+ ids[element] = ids.length
end
- return ids
- end
-
- redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mtypes(elements)
-end
-
-# Layout builder for MClass using Binary Matrix (BM)
-class BMClassLayoutBuilder
- super TypingLayoutBuilder[MClass]
-
- init(mmodule: MModule) do super
-
- # Compute mclasses ids and position using BM
- redef fun build_layout(mclasses) do
- var result = new Layout[MClass]
- result.ids = self.compute_ids(mclasses)
- result.pos = result.ids
+ result.ids = ids
+ result.pos = ids
return result
end
- redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mclasses(elements)
-end
-
-# Layout builder for MClass using Coloring (CL)
-class CLClassLayoutBuilder
- super TypingLayoutBuilder[MClass]
-
- private var colorer: MClassColorer
-
- init(mmodule: MModule) do
- super
- self.colorer = new MClassColorer(mmodule)
- end
-
- # Compute mclasses ids and position using BM
- redef fun build_layout(mclasses) do
- var result = new Layout[MClass]
- result.ids = self.compute_ids(mclasses)
- result.pos = self.colorer.colorize(mclasses)
- return result
- end
-
- redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mclasses(elements)
+ private fun reverse_linearize(elements: Set[E]): Array[E] is abstract
end
-# Layout builder for MClass using Perfect Hashing (PH)
-class PHClassLayoutBuilder
- super TypingLayoutBuilder[MClass]
-
- redef type LAYOUT: PHLayout[MClass, MClass]
-
- private var hasher: PerfectHasher[MClass, MClass]
-
- init(mmodule: MModule, operator: PHOperator) do
- super(mmodule)
- self.hasher = new PerfectHasher[MClass, MClass](operator)
- end
-
- private fun build_conflicts(mclasses: Set[MClass]): Map[MClass, Set[MClass]] do
- var conflicts = new HashMap[MClass, Set[MClass]]
- for mclass in mclasses do
- var supers = self.mmodule.super_mclasses(mclass)
- supers.add(mclass)
- conflicts[mclass] = supers
- end
- return conflicts
- end
+# Layout builder for typing tables based on classes using Binary Matrix (BM)
+class MTypeBMizer
+ super TypingBMizer[MType]
- # Compute mclasses ids and position using BM
- redef fun build_layout(mclasses) do
- var result = new PHLayout[MClass, MClass]
- var conflicts = build_conflicts(mclasses)
- result.ids = self.compute_ids(mclasses)
- result.masks = self.hasher.compute_masks(conflicts, result.ids)
- result.hashes = self.hasher.compute_hashes(conflicts, result.ids, result.masks)
- return result
- end
+ init(mmodule: MModule) do super(mmodule)
- # Ids start from 1 instead of 0
- redef fun compute_ids(mclasses) do
- var ids = new HashMap[MClass, Int]
- var lin = self.mmodule.reverse_linearize_mclasses(mclasses)
- for mclass in lin do
- ids[mclass] = ids.length + 1
- end
- return ids
+ redef fun reverse_linearize(elements) do
+ return self.mmodule.reverse_linearize_mtypes(elements)
end
-
- redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mclasses(elements)
-end
-
-abstract class PropertyLayoutBuilder[E: MProperty]
-
- type LAYOUT: PropertyLayout[E]
-
- # Compute properties ids and position
- fun build_layout(mclasses: Set[MClass]): LAYOUT is abstract
end
-# Layout builder for MProperty using Coloring (CL)
-class CLPropertyLayoutBuilder[E: MProperty]
- super PropertyLayoutBuilder[E]
+# Layout builder for typing tables based on types using Binary Matrix (BM)
+class MClassBMizer
+ super TypingBMizer[MClass]
- private var colorer: MPropertyColorer[E]
+ init(mmodule: MModule) do super(mmodule)
- init(colorer: MPropertyColorer[E]) do
- self.colorer = colorer
- end
-
- # Compute mclasses ids and position using BM
- redef fun build_layout(mclasses) do
- var result = new PropertyLayout[E]
- result.pos = self.colorer.colorize(mclasses)
- return result
+ redef fun reverse_linearize(elements) do
+ return self.mmodule.reverse_linearize_mclasses(elements)
end
end
-# Layout builder for MProperty using Perfect Hashing (PH)
-# TODO implement this class without sublcassing CL builder
-class PHPropertyLayoutBuilder[E: MProperty]
- super CLPropertyLayoutBuilder[E]
-end
-
-abstract class ResolutionLayoutBuilder
-
- type LAYOUT: Layout[MType]
+# Layout builder for resolution tables using Binary Matrix (BM)
+class ResolutionBMizer
+ super ResolutionLayoutBuilder
init do end
- fun build_layout(elements: Map[MClassType, Set[MType]]): LAYOUT is abstract
-
- fun compute_ids(elements: Map[MClassType, Set[MType]]): Map[MType, Int] do
+ redef fun build_layout(elements) do
+ var result = new Layout[MType]
var ids = new HashMap[MType, Int]
var color = 0
for mclasstype, mclasstypes in elements do
color += 1
end
end
- return ids
- end
-end
-
-# Layout builder for MClass using Binary Matrix (BM)
-class BMResolutionLayoutBuilder
- super ResolutionLayoutBuilder
-
- init do super
-
- # Compute resolved types position using BM
- redef fun build_layout(elements) do
- var result = new Layout[MType]
- result.ids = self.compute_ids(elements)
- result.pos = result.ids
+ result.ids = ids
+ result.pos = ids
return result
end
end
-# Layout builder for resolution tables using Coloring (CL)
-class CLResolutionLayoutBuilder
- super ResolutionLayoutBuilder
+# Abstract Layout builder for mproperties using Binary Matrix (BM)
+abstract class MPropertyBMizer[E: MProperty]
+ super PropertyLayoutBuilder[E]
- private var colorer: ResolutionColorer = new ResolutionColorer
+ type MPROP: MProperty
- init do super
+ var mmodule: MModule
+
+ init(mmodule: MModule) do self.mmodule = mmodule
- # Compute resolved types colors
redef fun build_layout(elements) do
- var result = new Layout[MType]
- result.ids = self.compute_ids(elements)
- result.pos = self.colorer.colorize(elements)
+ var result = new Layout[E]
+ var ids = new HashMap[E, Int]
+ var lin = linearize_mclasses(elements)
+ for mclass in lin do
+ for mproperty in properties(mclass) do
+ if ids.has_key(mproperty) then continue
+ ids[mproperty] = ids.length
+ end
+ end
+ result.pos = ids
return result
end
+
+ # extract properties of a mclass
+ private fun properties(mclass: MClass): Set[E] do
+ var properties = new HashSet[E]
+ for mprop in self.mmodule.properties(mclass) do
+ if mprop isa MPROP then properties.add(mprop)
+ end
+ return properties
+ end
+
+ private fun linearize_mclasses(mclasses: Set[MClass]): Array[MClass] is abstract
end
-# Layout builder for resolution table using Perfect Hashing (PH)
-class PHResolutionLayoutBuilder
- super ResolutionLayoutBuilder
+# Layout builder for vft using Binary Matrix (BM)
+class MMethodBMizer
+ super MPropertyBMizer[MMethod]
- redef type LAYOUT: PHLayout[MClassType, MType]
+ redef type MPROP: MMethod
+ init(mmodule: MModule) do super(mmodule)
+ # Less holes in tables with reverse linearization for method tables
+ redef fun linearize_mclasses(mclasses) do return self.mmodule.reverse_linearize_mclasses(mclasses)
+end
- private var hasher: PerfectHasher[MClassType, MType]
+# Layout builder for attribute tables using Binary Matrix (BM)
+class MAttributeBMizer
+ super MPropertyBMizer[MAttribute]
- init(operator: PHOperator) do self.hasher = new PerfectHasher[MClassType, MType](operator)
+ redef type MPROP: MAttribute
+ init(mmodule: MModule) do super(mmodule)
+ # Less holes in tables with linearization for attribute tables
+ redef fun linearize_mclasses(mclasses) do return self.mmodule.linearize_mclasses_2(mclasses)
+end
- # Compute resolved types masks and hashes
- redef fun build_layout(elements) do
- var result = new PHLayout[MClassType, MType]
- result.ids = self.compute_ids(elements)
- result.pos = result.ids
- result.masks = self.hasher.compute_masks(elements, result.ids)
- result.hashes = self.hasher.compute_hashes(elements, result.ids, result.masks)
- return result
- end
+# BMizing for MVirtualTypeProps
+class MVirtualTypePropBMizer
+ super MPropertyBMizer[MVirtualTypeProp]
- redef fun compute_ids(elements) do
- var ids = new HashMap[MType, Int]
- var color = 1
- for mclasstype, mclasstypes in elements do
- for element in mclasstypes do
- if ids.has_key(element) then continue
- ids[element] = color
- color += 1
- end
- end
- return ids
- end
+ redef type MPROP: MVirtualTypeProp
+ init(mmodule: MModule) do super(mmodule)
+ # Less holes in tables with reverse linearization for method tables
+ redef fun linearize_mclasses(mclasses) do return self.mmodule.reverse_linearize_mclasses(mclasses)
end
# Colorers
-abstract class AbstractColorer[E: Object]
+# 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]
init do end
- fun colorize(elements: Set[E]): Map[E, Int] do
+ # Compute the layout with coloring
+ redef fun build_layout(elements: Set[E]): Layout[E] do
+ var result = new Layout[E]
+ result.ids = compute_ids(elements)
+ result.pos = colorize(elements)
+ return result
+ end
+
+ 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
+ ids[element] = ids.length
+ end
+ return ids
+ end
+
+ private fun colorize(elements: Set[E]): Map[E, Int] do
tag_elements(elements)
build_conflicts_graph(elements)
colorize_elements(core)
private fun reverse_linearize(elements: Set[E]): Array[E] is abstract
end
-# MType coloring
-private class MTypeColorer
- super AbstractColorer[MType]
+# Layout builder for typing tables based on types using coloration (CL)
+class MTypeColorer
+ super TypingColorer[MType]
var mmodule: MModule
redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mtypes(elements)
end
-# MClass coloring
-private class MClassColorer
- super AbstractColorer[MClass]
+# Layout builder for typing tables based on classes using coloration (CL)
+class MClassColorer
+ super TypingColorer[MClass]
private var mmodule: MModule
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 linearize(elements) do return self.mmodule.linearize_mclasses_2(elements)
redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mclasses(elements)
end
-# MProperty coloring
+# Abstract Layout builder for properties tables using coloration (CL)
abstract class MPropertyColorer[E: MProperty]
+ super PropertyLayoutBuilder[E]
+
+ type MPROP: MProperty
private var mmodule: MModule
private var class_colorer: MClassColorer
self.class_colorer = new MClassColorer(mmodule)
end
- fun colorize(mclasses: Set[MClass]): Map[E, Int] do
+ # Compute mclasses ids and position using BM
+ redef fun build_layout(mclasses: Set[MClass]): Layout[E] do
+ var result = new Layout[E]
+ result.pos = self.colorize(mclasses)
+ 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)
end
# Filter properties
- private fun properties(mclass: MClass): Set[E] is abstract
+ private fun properties(mclass: MClass): Set[E] do
+ var properties = new HashSet[E]
+ for mprop in self.mmodule.properties(mclass) do
+ if mprop isa MPROP then properties.add(mprop)
+ end
+ return properties
+ end
end
-# Coloring for MMethods
+# Layout builder for vft using coloration (CL)
class MMethodColorer
super MPropertyColorer[MMethod]
+ redef type MPROP: 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
+# Layout builder for attributes using coloration (CL)
class MAttributeColorer
super MPropertyColorer[MAttribute]
+ redef type MPROP: 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
+# Layout builder for virtual types using coloration (CL)
class MVirtualTypePropColorer
super MPropertyColorer[MVirtualTypeProp]
+ redef type MPROP: 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
private var coloration_result: Map[MType, Int] = new HashMap[MType, Int]
init do end
- fun colorize(elements: Map[MClassType, Set[MType]]): Map[MType, Int] do
+ # Compute resolved types colors
+ redef fun build_layout(elements) do
self.build_conflicts_graph(elements)
- self.colorize_elements(elements)
- return coloration_result
+ var result = new Layout[MType]
+ result.ids = self.compute_ids(elements)
+ result.pos = self.colorize_elements(elements)
+ return result
+ end
+
+ private fun compute_ids(elements: Map[MClassType, Set[MType]]): Map[MType, Int] do
+ var ids = new HashMap[MType, Int]
+ var color = 0
+ for mclasstype, mclasstypes in elements do
+ for element in mclasstypes do
+ if ids.has_key(element) then continue
+ ids[element] = color
+ color += 1
+ end
+ end
+ return ids
end
# Colorize a collection of elements
- fun colorize_elements(elements: Map[MClassType, Set[MType]]) do
+ private fun colorize_elements(elements: Map[MClassType, Set[MType]]): Map[MType, Int] do
var min_color = 0
for mclasstype, mclasstypes in elements do
for element in mclasstypes do
color = min_color
end
end
+ return self.coloration_result
end
# Check if a related element to the element already use the color
init(operator: PHOperator) do self.operator = operator
+ # 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
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
# Abstract operator used for perfect hashing
abstract class PHOperator
+ # hash `id` using `mask`
fun op(mask: Int, id:Int): Int is abstract
end
init do end
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
+
+ init(operator: PHOperator, mmodule: MModule) do
+ super(operator)
+ self.mmodule = mmodule
+ end
+
+ redef fun build_layout(elements: Set[E]): PHLayout[E, E] do
+ var result = new PHLayout[E, E]
+ var conflicts = self.build_conflicts(elements)
+ result.ids = self.compute_ids(elements)
+ 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
+ var ids = new HashMap[E, Int]
+ var lin = self.reverse_linearize(elements)
+ for e in lin do
+ ids[e] = ids.length + 1
+ end
+ return ids
+ end
+
+ 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)
+ 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
+end
+
+# Layout builder for typing tables with classes using perfect hashing (PH)
+class MClassHasher
+ super TypingHasher[MClass]
+
+ init(operator: PHOperator, mmodule: MModule) do super(operator, mmodule)
+
+ redef fun super_elements(element, elements) do
+ return self.mmodule.super_mclasses(element)
+ end
+
+ redef fun reverse_linearize(elements) do
+ return self.mmodule.reverse_linearize_mclasses(elements)
+ end
+end
+
+# Abstract layout builder for properties tables using perfect hashing (PH)
+class MPropertyHasher[E: MProperty]
+ super PerfectHasher[MClass, E]
+ super PropertyLayoutBuilder[E]
+
+ type MPROP: MProperty
+
+ var mmodule: MModule
+
+ init(operator: PHOperator, mmodule: MModule) do
+ super(operator)
+ self.mmodule = mmodule
+ end
+
+ redef fun build_layout(mclasses) do
+ var result = new PHLayout[MClass, E]
+ var ids = new HashMap[E, Int]
+ var elements = new HashMap[MClass, Set[E]]
+ var lin = linearize_mclasses(mclasses)
+ for mclass in lin do
+ var mproperties = properties(mclass)
+ for mproperty in mproperties do
+ if ids.has_key(mproperty) then continue
+ ids[mproperty] = ids.length + 1
+ end
+ elements[mclass] = mproperties
+ 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
+
+ # extract set of properties from mclass
+ private fun properties(mclass: MClass): Set[E] do
+ var properties = new HashSet[E]
+ for mprop in self.mmodule.properties(mclass) do
+ if mprop isa MPROP then properties.add(mprop)
+ end
+ return properties
+ end
+
+ private fun linearize_mclasses(mclasses: Set[MClass]): Array[MClass] is abstract
+end
+
+# Layout builder for vft using perfect hashing (PH)
+class MMethodHasher
+ super MPropertyHasher[MMethod]
+
+ redef type MPROP: MMethod
+ init(operator: PHOperator, mmodule: MModule) do super(operator, mmodule)
+ redef fun linearize_mclasses(mclasses) do return self.mmodule.reverse_linearize_mclasses(mclasses)
+end
+
+# Layout builder for attributes tables using perfect hashing (PH)
+class MAttributeHasher
+ super MPropertyHasher[MAttribute]
+
+ redef type MPROP: MAttribute
+ init(operator: PHOperator, mmodule: MModule) do super(operator, mmodule)
+ redef fun linearize_mclasses(mclasses) do return self.mmodule.linearize_mclasses_2(mclasses)
+end
+
+# Layout builder for virtual types tables using perfect hashing (PH)
+class MVirtualTypePropHasher
+ super MPropertyHasher[MVirtualTypeProp]
+
+ redef type MPROP: MVirtualTypeProp
+ init(operator: PHOperator, mmodule: MModule) do super(operator, mmodule)
+ redef fun linearize_mclasses(mclasses) do return self.mmodule.reverse_linearize_mclasses(mclasses)
+end
+
+# Layout builder for resolution tables using perfect hashing (PH)
+class ResolutionHasher
+ super PerfectHasher[MClassType, MType]
+ super ResolutionLayoutBuilder
+
+ init(operator: PHOperator) do super(operator)
+
+ # Compute resolved types masks and hashes
+ redef fun build_layout(elements) do
+ var result = new PHLayout[MClassType, MType]
+ var ids = new HashMap[MType, Int]
+ var color = 1
+ for mclasstype, mclasstypes in elements do
+ for element in mclasstypes do
+ if ids.has_key(element) then continue
+ ids[element] = color
+ color += 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
nitlanguage / nit.git / blobdiff