# Graph coloring tools
module coloring
-import rapid_type_analysis # for type coloration
+import typing
-abstract class AbstractColoring[E: Object]
+# Layouts
- private var sorter: AbstractSorter[E]
- private var reverse_sorter: AbstractSorter[E]
+class TypingLayout[E]
+ # Unic ids or each element
+ var ids: Map[E, Int] = new HashMap[E, Int]
+ # Fixed positions of each element in all tables
+ var pos: Map[E, Int] = new HashMap[E, Int]
+end
+
+class PHTypingLayout[E]
+ super TypingLayout[E]
+ # Masks used by hash function
+ var masks: Map[E, Int] = new HashMap[E, Int]
+ # Positions of each element for each tables
+ var hashes: Map[E, Map[E, Int]] = new HashMap[E, Map[E, Int]]
+end
- private var core: OrderedSet[E] = new OrderedSet[E]
- private var crown: OrderedSet[E] = new OrderedSet[E]
- private var border: OrderedSet[E] = new OrderedSet[E]
+# Builders
- private var coloration_result: Map[E, Int] = new HashMap[E, Int]
- private var conflicts_graph_cache: nullable HashMap[E, Set[E]]
+abstract class TypingLayoutBuilder[E]
+
+ type LAYOUT: TypingLayout[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
+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 TypingLayout[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)
+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 TypingLayout[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)
+end
+
+# Layout builder for MType using Perfect Hashing (PH)
+class PHTypeLayoutBuilder
+ super TypingLayoutBuilder[MType]
+
+ redef type LAYOUT: PHTypingLayout[MType]
+
+ private var hasher: MTypeHasher
+
+ init(mmodule: MModule, operator: PHOperator) do
+ super
+ self.hasher = new MTypeHasher(mmodule, operator)
+ end
+
+ # Compute mtypes ids and position using BM
+ redef fun build_layout(mtypes) do
+ var result = new PHTypingLayout[MType]
+ result.ids = self.compute_ids(mtypes)
+ result.masks = self.hasher.compute_masks(mtypes, result.ids)
+ result.hashes = self.hasher.compute_hashes(mtypes, 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
+ 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 TypingLayout[MClass]
+ result.ids = self.compute_ids(mclasses)
+ result.pos = result.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(sorter: AbstractSorter[E], reverse_sorter: AbstractSorter[E]) do
- self.sorter = sorter
- self.reverse_sorter = reverse_sorter
+ init(mmodule: MModule) do
+ super
+ self.colorer = new MClassColorer(mmodule)
end
- fun colorize(elements: Collection[E]): Map[E, Int] do
- # tag each element as part of group core, crown or border
- for e in elements do
- tag_element(e)
+ # Compute mclasses ids and position using BM
+ redef fun build_layout(mclasses) do
+ var result = new TypingLayout[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)
+end
+
+# Layout builder for MClass using Perfect Hashing (PH)
+class PHClassLayoutBuilder
+ super TypingLayoutBuilder[MClass]
+
+ redef type LAYOUT: PHTypingLayout[MClass]
+
+ private var hasher: MClassHasher
+
+ init(mmodule: MModule, operator: PHOperator) do
+ super
+ self.hasher = new MClassHasher(mmodule, operator)
+ end
+
+ # Compute mclasses ids and position using BM
+ redef fun build_layout(mclasses) do
+ var result = new PHTypingLayout[MClass]
+ result.ids = self.compute_ids(mclasses)
+ result.masks = self.hasher.compute_masks(mclasses, result.ids)
+ result.hashes = self.hasher.compute_hashes(mclasses, result.ids, result.masks)
+ return result
+ end
+
+ # 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
+ end
+
+ redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mclasses(elements)
+end
+
+# Colorers
+
+abstract class AbstractColorer[E: Object]
- #print "core: {core.join(", ")}"
- #print "border: {border.join(", ")}"
- #print "crown: {crown.join(", ")}"
+ private var core: Set[E] = new HashSet[E]
+ private var crown: Set[E] = new HashSet[E]
+ private var border: Set[E] = new HashSet[E]
- # sort by reverse linearization order
- reverse_sorter.sort(core)
- reverse_sorter.sort(border)
- reverse_sorter.sort(crown)
+ private var coloration_result: Map[E, Int] = new HashMap[E, Int]
- #print "conflicts"
- #for k, v in conflicts_graph do
- # if k isa MType then
- # print "{k}: {v.join(", ")}"
- # end
- #end
+ init do end
- # colorize graph
+ fun colorize(elements: Set[E]): Map[E, Int] do
+ tag_elements(elements)
+ build_conflicts_graph(elements)
colorize_elements(core)
colorize_elements(border)
colorize_elements(crown)
-
return coloration_result
end
# Colorize a collection of elements
- private fun colorize_elements(elements: Collection[E]) do
+ private fun colorize_elements(elements: Set[E]) do
var min_color = 0
- for element in elements do
+ var lin = reverse_linearize(elements)
+ for element in lin do
var color = min_color
- while not self.is_color_free(element, color) do
+ while not self.is_color_free(element, elements, color) do
color += 1
end
coloration_result[element] = color
end
# Check if a related element to the element already use the color
- private fun is_color_free(element: E, color: Int): Bool do
+ private fun is_color_free(element: E, elements: Set[E], color: Int): Bool do
if conflicts_graph.has_key(element) then
for st in conflicts_graph[element] do
if coloration_result.has_key(st) and coloration_result[st] == color then return false
end
end
- for st in self.super_elements(element) do
+ for st in self.super_elements(element, elements) do
if coloration_result.has_key(st) and coloration_result[st] == color then return false
end
return true
end
- # Tag element as core, crown or border
- private fun tag_element(element: E) do
- # Check if sub elements are all in single inheritance
- var all_subelements_si = true
- for subelem in self.sub_elements(element) do
- if self.is_element_mi(subelem) then
- all_subelements_si = false
- break
+ # Tag elements as core, crown or border
+ private fun tag_elements(elements: Set[E]) do
+ 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
+ all_subelements_si = false
+ break
+ end
end
- end
- # Tag as core, crown or border
- if self.is_element_mi(element) then
- core.add_all(self.super_elements(element))
- core.add(element)
- if all_subelements_si then
- border.add(element)
+ # 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 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)
+ else
+ crown.add(element)
end
- else if not all_subelements_si then
- core.add_all(self.super_elements(element))
- core.add(element)
- else
- crown.add(element)
end
end
# Conflicts graph of elements hierarchy (two types are in conflict if they have common subelements)
- private fun conflicts_graph: Map[E, Set[E]] do
- if self.conflicts_graph_cache == null then
- self.conflicts_graph_cache = new HashMap[E, HashSet[E]]
- for t in self.core do
- for i in self.linear_extension(t) do
- if t == i then continue
-
- var lin_i = self.linear_extension(i)
-
- for j in self.linear_extension(t) do
- if i == j or j == t then continue
- var lin_j = self.linear_extension(j)
-
- var d_ij = lin_i - lin_j
- var d_ji = lin_j - lin_i
-
- for ed1 in d_ij do
- if not conflicts_graph_cache.has_key(ed1) then conflicts_graph_cache[ed1] = new HashSet[E]
- # add ed1 x ed2 to conflicts graph
- for ed2 in d_ji do conflicts_graph_cache[ed1].add(ed2)
- end
- for ed1 in d_ij do
- if not conflicts_graph_cache.has_key(ed1) then conflicts_graph_cache[ed1] = new HashSet[E]
- # add ed1 x ed2 to conflicts graph
- for ed2 in d_ji do conflicts_graph_cache[ed1].add(ed2)
- end
+ private fun build_conflicts_graph(elements: Set[E]) 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
+ if t == i then continue
+
+ var lin_i = self.linear_extension(i, elements)
+
+ for j in self.linear_extension(t, elements) do
+ if i == j or j == t then continue
+ var lin_j = self.linear_extension(j, elements)
+
+ var d_ij = lin_i - lin_j
+ var d_ji = lin_j - lin_i
+
+ for ed1 in d_ij do
+ if not conflicts_graph.has_key(ed1) then conflicts_graph[ed1] = new HashSet[E]
+ # add ed1 x ed2 to conflicts graph
+ for ed2 in d_ji do conflicts_graph[ed1].add(ed2)
+ end
+ for ed1 in d_ij do
+ if not conflicts_graph.has_key(ed1) then conflicts_graph[ed1] = new HashSet[E]
+ # add ed1 x ed2 to conflicts graph
+ for ed2 in d_ji do conflicts_graph[ed1].add(ed2)
end
end
end
end
- return conflicts_graph_cache.as(not null)
end
+ private var conflicts_graph: nullable HashMap[E, Set[E]]
+
# cache for linear_extensions
- private var linear_extensions_cache: Map[E, OrderedSet[E]] = new HashMap[E, OrderedSet[E]]
+ 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): OrderedSet[E] do
+ private fun linear_extension(element: E, elements: Set[E]): Array[E] do
if not self.linear_extensions_cache.has_key(element) then
- var lin = new OrderedSet[E]
- lin.add(element)
- lin.add_all(self.super_elements(element))
- self.sorter.sort(lin)
- self.linear_extensions_cache[element] = lin
+ var supers = new HashSet[E]
+ supers.add(element)
+ supers.add_all(self.super_elements(element, elements))
+ self.linear_extensions_cache[element] = self.linearize(supers)
end
return self.linear_extensions_cache[element]
end
- # Return all super elements (directs and indirects) of an element
- private fun super_elements(element: E): Collection[E] is abstract
+ 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
+end
- # Return all sub elements (directs and indirects) of an element
- private fun sub_elements(element: E): Collection[E] is abstract
+# MType coloring
+private class MTypeColorer
+ super AbstractColorer[MType]
- # Is the element in multiple inheritance ?
- private fun is_element_mi(element: E): Bool is abstract
-end
+ var mmodule: MModule
+
+ init(mmodule: MModule) do self.mmodule = mmodule
-# MClassType coloring
-class TypeColoring
- super AbstractColoring[MType]
+ 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)
+end
- type T: MType
+# MClass coloring
+private class MClassColorer
+ super AbstractColorer[MClass]
private var mmodule: MModule
- private var mtypes: Set[T]
- # caches
- private var super_elements_cache: Map[T, Set[T]] = new HashMap[T, Set[T]]
- private var sub_elements_cache: Map[T, Set[T]] = new HashMap[T, Set[T]]
+ init(mmodule: MModule) do self.mmodule = mmodule
- init(mainmodule: MModule, mtypes: Set[T]) do
- super(new TypeSorter(mainmodule), new ReverseTypeSorter(mainmodule))
- self.mmodule = mainmodule
- self.mtypes = mtypes
- end
+ 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)
+end
- # Build type tables
- private fun build_type_tables(mtypes: Set[T], colors: Map[T, Int]): Map[T, Array[nullable T]] do
- var tables = new HashMap[T, Array[nullable T]]
+# Perfect hashers
- for mtype in mtypes do
- var table = new Array[nullable T]
- var supers = new HashSet[T]
- supers.add_all(self.super_elements(mtype))
- supers.add(mtype)
- for sup in supers do
- var color = colors[sup]
- if table.length <= color then
- for i in [table.length .. color[ do
- table[i] = null
- end
- end
- table[color] = sup
- end
- tables[mtype] = table
+# Abstract Perfect Hashing
+private abstract class AbstractHasher[E: Object]
+
+ var operator: PHOperator
+
+ init(operator: PHOperator) do self.operator = operator
+
+ fun compute_masks(elements: Set[E], ids: Map[E, Int]): Map[E, Int] do
+ var masks = new HashMap[E, Int]
+ for element in elements do
+ var supers = new HashSet[E]
+ supers.add_all(self.super_elements(element, elements))
+ supers.add(element)
+ masks[element] = compute_mask(supers, ids)
end
- return tables
+ return masks
end
- redef fun super_elements(element) do
- if not self.super_elements_cache.has_key(element) then
- var supers = new HashSet[T]
- for mtype in self.mtypes do
- if element == mtype then continue
- if element.is_subtype(self.mmodule, null, mtype) then
- supers.add(mtype)
+ fun compute_mask(supers: Set[E], ids: Map[E, Int]): Int do
+ var mask = 0
+ loop
+ var used = new List[Int]
+ for sup in supers do
+ var res = operator.op(mask, ids[sup])
+ if used.has(res) then
+ break
+ else
+ used.add(res)
end
end
- self.super_elements_cache[element] = supers
+ if used.length == supers.length then break
+ mask += 1
end
- return self.super_elements_cache[element]
- end
-
- # Return all direct super elements of an element
- redef fun is_element_mi(element) do
- return self.super_elements(element).length > 1
+ return mask
end
- # Return all sub elements (directs and indirects) of an element
- redef fun sub_elements(element) do
- if not self.sub_elements_cache.has_key(element) then
- var subs = new HashSet[T]
- for mtype in self.mtypes do
- if element == mtype then continue
- if mtype.is_subtype(self.mmodule, null, element) then
- subs.add(mtype)
- end
+ fun compute_hashes(elements: Set[E], ids: Map[E, Int], masks: Map[E, Int]): Map[E, Map[E, Int]] do
+ var hashes = new HashMap[E, Map[E, Int]]
+ for element in elements do
+ var supers = new HashSet[E]
+ supers.add_all(self.super_elements(element, elements))
+ supers.add(element)
+ var inhashes = new HashMap[E, Int]
+ var mask = masks[element]
+ for sup in supers do
+ inhashes[sup] = operator.op(mask, ids[sup])
end
- self.sub_elements_cache[element] = subs
+ hashes[element] = inhashes
end
- return self.sub_elements_cache[element]
+ return hashes
end
+
+ fun super_elements(element: E, elements: Set[E]): Set[E] is abstract
end
-# A sorter for linearize list of types
-private class TypeSorter
- super AbstractSorter[MType]
+# Abstract operator used for perfect hashing
+abstract class PHOperator
+ fun op(mask: Int, id:Int): Int is abstract
+end
- private var mmodule: MModule
+# Hashing using modulo (MOD) operator
+# slower but compact
+class PHModOperator
+ super PHOperator
+ init do end
+ redef fun op(mask, id) do return mask % id
+end
- init(mmodule: MModule) do self.mmodule = mmodule
+# Hashing using binary and (AND) operator
+# faster but sparse
+class PHAndOperator
+ super PHOperator
+ init do end
+ redef fun op(mask, id) do return mask.bin_and(id)
+end
- redef fun compare(a, b) do
- if a == b then
- return 0
- else if a.is_subtype(self.mmodule, null, b) then
- return -1
- end
- return 1
+# MType Perfect Hashing
+private class MTypeHasher
+ super AbstractHasher[MType]
+
+ var mmodule: MModule
+
+ init(mmodule: MModule, operator: PHOperator) do
+ super(operator)
+ self.mmodule = mmodule
end
+
+ redef fun super_elements(element, elements) do return self.mmodule.super_mtypes(element, elements)
end
-# A sorter for reverse linearization
-private class ReverseTypeSorter
- super TypeSorter
+# MClass Perfect Hashing
+private class MClassHasher
+ super AbstractHasher[MClass]
- redef fun compare(a, b) do
- if a == b then
- return 0
- else if a.is_subtype(self.mmodule, null, b) then
- return 1
- end
- return -1
+ private var mmodule: MModule
+
+ init(mmodule: MModule, operator: PHOperator) do
+ super(operator)
+ self.mmodule = mmodule
end
+
+ redef fun super_elements(element, elements) do return self.mmodule.super_mclasses(element)
end
# MClass coloring
class ClassColoring
- super AbstractColoring[MClass]
+ super AbstractColorer[MClass]
type T: MClass
private var parent_elements_cache: Map[T, Set[T]] = new HashMap[T, Set[T]]
private var sub_elements_cache: Map[T, Set[T]] = new HashMap[T, Set[T]]
- init(mainmodule: MModule) do
- super(new ClassSorter(mainmodule), new ReverseClassSorter(mainmodule))
- self.mmodule = mainmodule
- end
-
- # Build type tables
- private fun build_type_tables(mclasses: Array[T], colors: Map[T, Int]): Map[T, Array[nullable T]] do
- var tables = new HashMap[T, Array[nullable T]]
-
- for mclasse in mclasses do
- var table = new Array[nullable T]
- var supers = new HashSet[T]
- supers.add_all(self.super_elements(mclasse))
- supers.add(mclasse)
- for sup in supers do
- var color = colors[sup]
- if table.length <= color then
- for i in [table.length .. color[ do
- table[i] = null
- end
- end
- table[color] = sup
- end
- tables[mclasse] = table
- end
- return tables
- end
-
- redef fun super_elements(element) do
- if not self.super_elements_cache.has_key(element) then
- var supers = new HashSet[T]
- if self.mmodule.flatten_mclass_hierarchy.has(element) then
- for sup in self.mmodule.flatten_mclass_hierarchy[element].greaters do
- if element == sup then continue
- supers.add(sup)
- end
- end
- self.super_elements_cache[element] = supers
- end
- return self.super_elements_cache[element]
- end
-
- private fun parent_elements(element: T): Set[T] do
- if not self.parent_elements_cache.has_key(element) then
- var parents = new HashSet[T]
- if self.mmodule.flatten_mclass_hierarchy.has(element) then
- for parent in self.mmodule.flatten_mclass_hierarchy[element].direct_greaters do
- if element == parent then continue
- parents.add(parent)
- end
- end
- self.parent_elements_cache[element] = parents
- end
- return self.parent_elements_cache[element]
- end
-
- # Return all sub elements (directs and indirects) of an element
- redef fun sub_elements(element) do
- if not self.sub_elements_cache.has_key(element) then
- var subs = new HashSet[T]
- if self.mmodule.flatten_mclass_hierarchy.has(element) then
- for sub in self.mmodule.flatten_mclass_hierarchy[element].smallers do
- subs.add(sub)
- end
- end
- self.sub_elements_cache[element] = subs
- end
- return self.sub_elements_cache[element]
- end
-
- # Return all direct super elements of an element
- redef fun is_element_mi(element) do
- if not self.mmodule.flatten_mclass_hierarchy.has(element) then return false
- return self.mmodule.flatten_mclass_hierarchy[element].direct_greaters.length > 1
- end
-end
-
-# A sorter for linearize list of classes
-private class ClassSorter
- super AbstractSorter[MClass]
-
- var mmodule: MModule
-
- redef fun compare(a, b) do
- if a == b then
- return 0
- else if self.mmodule.flatten_mclass_hierarchy.has(a) and self.mmodule.flatten_mclass_hierarchy[a].greaters.has(b) then
- return -1
- end
- return 1
- end
-end
-
-# A sorter for reverse linearization
-private class ReverseClassSorter
- super AbstractSorter[MClass]
-
- var mmodule: MModule
+ init(mainmodule: MModule) do self.mmodule = mainmodule
- redef fun compare(a, b) do
- if a == b then
- return 0
- else if self.mmodule.flatten_mclass_hierarchy.has(a) and self.mmodule.flatten_mclass_hierarchy[a].greaters.has(b) then
- return 1
- end
- return -1
- end
+ 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)
end
# MProperty coloring
type MPROP: MProperty
type MPROPDEF: MPropDef
+ private var mmodule: MModule
private var class_coloring: ClassColoring
private var coloration_result: Map[MPROP, Int] = new HashMap[MPROP, Int]
- init(class_coloring: ClassColoring) do
+ init(mmodule: MModule, class_coloring: ClassColoring) do
+ self.mmodule = mmodule
self.class_coloring = class_coloring
end
- private fun colorize: Map[MPROP, Int] do
+ fun colorize: Map[MPROP, Int] do
colorize_core_properties
colorize_crown_properties
return self.coloration_result
end
- private fun build_property_tables: Map[MClass, Array[nullable MPROPDEF]] do
- var tables = new HashMap[MClass, Array[nullable MPROPDEF]]
-
- for mclass in self.class_coloring.coloration_result.keys do
- var table = new Array[nullable MPROPDEF]
- # first, fill table from parents by reverse linearization order
- var parents = new OrderedSet[MClass]
- parents.add_all(self.class_coloring.super_elements(mclass))
- self.class_coloring.reverse_sorter.sort(parents)
- for parent in parents do
- for mproperty in self.properties(parent) do
- var color = self.coloration_result[mproperty]
- if table.length <= color then
- for i in [table.length .. color[ do
- table[i] = null
- end
- end
- for mpropdef in mproperty.mpropdefs do
- if mpropdef.mclassdef.mclass == parent then
- table[color] = mpropdef
- end
- end
- end
- end
-
- # then override with local properties
- for mproperty in self.properties(mclass) do
- var color = self.coloration_result[mproperty]
- if table.length <= color then
- for i in [table.length .. color[ do
- table[i] = null
- end
- end
- for mpropdef in mproperty.mpropdefs do
- if mpropdef.mclassdef.mclass == mclass then
- table[color] = mpropdef
- end
- end
- end
- tables[mclass] = table
- end
- return tables
- end
-
# Colorize properties of the core hierarchy
private fun colorize_core_properties do
var mclasses = self.class_coloring.core
return max_color
end
- # properties cache
- private var properties_cache: Map[MClass, Set[MPROP]] = new HashMap[MClass, Set[MPROP]]
-
# All 'mproperties' associated to all 'mclassdefs' of the class
private fun properties(mclass: MClass): Set[MPROP] do
- if not self.properties_cache.has_key(mclass) then
- var properties = new HashSet[MPROP]
- var parents = self.class_coloring.super_elements(mclass)
- for parent in parents do
- properties.add_all(self.properties(parent))
- end
-
- for mclassdef in mclass.mclassdefs do
- for mpropdef in mclassdef.mpropdefs do
- var mproperty = mpropdef.mproperty
- if mproperty isa MPROP then
- properties.add(mproperty)
- end
- end
- end
- self.properties_cache[mclass] = properties
- end
- return properties_cache[mclass]
- end
-end
+ var properties = new HashSet[MPROP]
+ for mprop in self.mmodule.properties(mclass) do
+ if mprop isa MPROP then properties.add(mprop)
+ end
+ return properties
+ end
+end
# MMethod coloring
class MethodColoring
redef type MPROP: MMethod
redef type MPROPDEF: MMethodDef
- init(class_coloring: ClassColoring) do end
+ init(mmodule: MModule, class_coloring: ClassColoring) do super
end
# MAttribute coloring
redef type MPROP: MAttribute
redef type MPROPDEF: MAttributeDef
- init(class_coloring: ClassColoring) do end
+ init(mmodule: MModule, class_coloring: ClassColoring) do super
end
# MVirtualTypeProp coloring
redef type MPROP: MVirtualTypeProp
redef type MPROPDEF: MVirtualTypeDef
- init(class_coloring: ClassColoring) do end
+ init(mmodule: MModule, class_coloring: ClassColoring) do super
+end
+
+class NaiveVTColoring
+ super VTColoring
+
+ init(mmodule: MModule, class_coloring: ClassColoring) do super
+
+ redef fun colorize: Map[MPROP, Int] do
+ var mclasses = new HashSet[MClass]
+ mclasses.add_all(self.class_coloring.core)
+ mclasses.add_all(self.class_coloring.crown)
+ var min_color = 0
+
+ for mclass in mclasses do
+ min_color = max_color(min_color, mclasses)
+ colorize_elements(self.properties(mclass), min_color)
+ end
+ return self.coloration_result
+ end
+end
+
+abstract class VTPerfectHashing
+ super VTColoring
+
+ private var masks: Map[MClass, Int] = new HashMap[MClass, Int]
+
+ init(mmodule: MModule, class_coloring: ClassColoring) do super
+
+ redef fun colorize: Map[MPROP, Int] do
+ var mclasses = new HashSet[MClass]
+ mclasses.add_all(self.class_coloring.core)
+ mclasses.add_all(self.class_coloring.crown)
+ for mclass in mclasses do
+ var vts = self.properties(mclass)
+ for vt in vts do
+ if coloration_result.has_key(vt) then continue
+ coloration_result[vt] = coloration_result.length + 1
+ end
+ end
+ return self.coloration_result
+ end
+
+ fun compute_masks: Map[MClass, Int] do
+ var mclasses = new HashSet[MClass]
+ mclasses.add_all(self.class_coloring.core)
+ mclasses.add_all(self.class_coloring.crown)
+ for mclass in mclasses do
+ self.masks[mclass] = compute_mask(self.properties(mclass))
+ end
+ return self.masks
+ end
+
+ private fun compute_mask(vts: Set[MPROP]): Int do
+ var mask = 0
+ loop
+ var used = new List[Int]
+ for vt in vts do
+ var res = op(mask, self.coloration_result[vt])
+ if used.has(res) then
+ break
+ else
+ used.add(res)
+ end
+ end
+ if used.length == vts.length then break
+ mask += 1
+ end
+ return mask
+ end
+
+ fun build_property_tables: Map[MClass, Array[nullable MPROPDEF]] do
+ var tables = new HashMap[MClass, Array[nullable MPROPDEF]]
+
+ for mclass in self.class_coloring.coloration_result.keys do
+ var table = new Array[nullable MPROPDEF]
+ # first, fill table from parents by reverse linearization order
+ var parents = self.class_coloring.mmodule.super_mclasses(mclass)
+ var lin = self.class_coloring.reverse_linearize(parents)
+ for parent in lin do
+ for mproperty in self.properties(parent) do
+ var color = phash(self.coloration_result[mproperty], masks[mclass])
+ if table.length <= color then
+ for i in [table.length .. color[ do
+ table[i] = null
+ end
+ end
+ for mpropdef in mproperty.mpropdefs do
+ if mpropdef.mclassdef.mclass == parent then
+ table[color] = mpropdef
+ end
+ end
+ end
+ end
+
+ # then override with local properties
+ for mproperty in self.properties(mclass) do
+ var color = phash(self.coloration_result[mproperty], masks[mclass])
+ if table.length <= color then
+ for i in [table.length .. color[ do
+ table[i] = null
+ end
+ end
+ for mpropdef in mproperty.mpropdefs do
+ if mpropdef.mclassdef.mclass == mclass then
+ table[color] = mpropdef
+ end
+ end
+ end
+ tables[mclass] = table
+ end
+ return tables
+ end
+
+ private fun op(mask: Int, id:Int): Int is abstract
+ private fun phash(id: Int, mask: Int): Int do return op(mask, id)
+
+end
+
+class VTModPerfectHashing
+ super VTPerfectHashing
+ init(mmodule: MModule, class_coloring: ClassColoring) do super
+ redef fun op(mask, id) do return mask % id
+end
+
+class VTAndPerfectHashing
+ super VTPerfectHashing
+ init(mmodule: MModule, class_coloring: ClassColoring) do super
+ redef fun op(mask, id) do return mask.bin_and(id)
end
# MParameterType coloring
self.class_coloring = class_coloring
end
- private fun colorize: Map[MParameterType, Int] do
+ fun colorize: Map[MParameterType, Int] do
colorize_core_properties
colorize_crown_properties
return self.coloration_result
return fts_cache[mclass]
end
- private fun build_ft_tables: Map[MClass, Array[nullable MParameterType]] do
+ fun build_ft_tables: Map[MClass, Array[nullable MParameterType]] do
var tables = new HashMap[MClass, Array[nullable MParameterType]]
for mclass in self.class_coloring.coloration_result.keys do
var table = new Array[nullable MParameterType]
# first, fill table from parents
- for parent in self.class_coloring.super_elements(mclass) do
+ var parents = self.class_coloring.mmodule.super_mclasses(mclass)
+ for parent in parents do
for ft in self.fts(parent) do
var color = self.coloration_result[ft]
if table.length <= color then
end
end
-# Live Entries coloring
-class LiveEntryColoring
+class NaiveFTColoring
+ super FTColoring
- private var coloration_result: Map[MType, Int] = new HashMap[MType, Int]
- private var conflicts_graph_cache: nullable HashMap[MType, Set[MType]]
- var livetypes_tables_sizes: nullable Map[MClass, Array[Int]]
+ init(class_coloring: ClassColoring) do end
- init do end
+ redef fun colorize: Map[MParameterType, Int] do
+ var mclasses = new HashSet[MClass]
+ mclasses.add_all(self.class_coloring.core)
+ mclasses.add_all(self.class_coloring.crown)
+ var min_color = 0
- fun colorize(elements: Collection[MType]): Map[MType, Int] do
- # compute conflicts
- build_conflicts_graph(elements)
+ for mclass in mclasses do
+ min_color = max_color(min_color, mclasses)
+ colorize_elements(self.fts(mclass), min_color)
+ end
+ return self.coloration_result
+ end
+end
- # colorize graph
- colorize_elements(elements)
+abstract class FTPerfectHashing
+ super FTColoring
- return coloration_result
+ private var masks: Map[MClass, Int] = new HashMap[MClass, Int]
+
+ init(class_coloring: ClassColoring) do end
+
+ redef fun colorize: Map[MParameterType, Int] do
+ var mclasses = new HashSet[MClass]
+ mclasses.add_all(self.class_coloring.core)
+ mclasses.add_all(self.class_coloring.crown)
+ for mclass in mclasses do
+ for ft in self.fts(mclass) do
+ if coloration_result.has_key(ft) then continue
+ coloration_result[ft] = coloration_result.length + 1
+ end
+ end
+ return self.coloration_result
end
- # Build type tables
- private fun build_livetype_tables(mtypes: Set[MType]): Map[MClass, Array[nullable Object]] do
- var livetypes_tables = new HashMap[MClass, Array[nullable Object]]
- self.livetypes_tables_sizes = new HashMap[MClass, Array[Int]]
+ fun compute_masks: Map[MClass, Int] do
+ var mclasses = new HashSet[MClass]
+ mclasses.add_all(self.class_coloring.core)
+ mclasses.add_all(self.class_coloring.crown)
+ for mclass in mclasses do
+ var fts = new HashSet[MParameterType]
+ var parents = self.class_coloring.mmodule.super_mclasses(mclass)
+ for parent in parents do
+ fts.add_all(self.fts(parent))
+ end
+ fts.add_all(self.fts(mclass))
+ self.masks[mclass] = compute_mask(fts)
+ end
+ return self.masks
+ end
- for mtype in mtypes do
- if mtype isa MGenericType then
- var table: Array[nullable Object]
- var sizes: Array[Int]
- if livetypes_tables.has_key(mtype.mclass) then
- table = livetypes_tables[mtype.mclass]
- else
- table = new Array[nullable Object]
- livetypes_tables[mtype.mclass] = table
- end
- if livetypes_tables_sizes.has_key(mtype.mclass) then
- sizes = livetypes_tables_sizes[mtype.mclass]
+ private fun compute_mask(fts: Set[MParameterType]): Int do
+ var mask = 0
+ loop
+ var used = new List[Int]
+ for ft in fts do
+ var res = op(mask, self.coloration_result[ft])
+ if used.has(res) then
+ break
else
- sizes = new Array[Int]
- livetypes_tables_sizes[mtype.mclass] = sizes
+ used.add(res)
end
- build_livetype_table(mtype, 0, table, sizes)
end
+ if used.length == fts.length then break
+ mask += 1
end
-
- return livetypes_tables
+ return mask
end
- # Build live gentype table recursively
- private fun build_livetype_table(mtype: MGenericType, current_rank: Int, table: Array[nullable Object], sizes: Array[Int]) do
- var ft = mtype.arguments[current_rank]
- if not self.coloration_result.has_key(ft) then return
- var color = self.coloration_result[ft]
+ redef fun build_ft_tables do
+ var tables = new HashMap[MClass, Array[nullable MParameterType]]
- if current_rank >= sizes.length then
- sizes[current_rank] = color + 1
- else if color >= sizes[current_rank] then
- sizes[current_rank] = color + 1
- end
+ for mclass in self.class_coloring.coloration_result.keys do
+ var table = new Array[nullable MParameterType]
+
+ # first, fill table from parents
+ var parents = self.class_coloring.mmodule.super_mclasses(mclass)
+ for parent in parents do
+ for ft in self.fts(parent) do
+ var color = phash(self.coloration_result[ft], masks[mclass])
+ if table.length <= color then
+ for i in [table.length .. color[ do
+ table[i] = null
+ end
+ end
+ table[color] = ft
+ end
+ end
- if color > table.length then
- for i in [table.length .. color[ do table[i] = null
+ # then override with local properties
+ for ft in self.fts(mclass) do
+ var color = phash(self.coloration_result[ft], masks[mclass])
+ if table.length <= color then
+ for i in [table.length .. color[ do
+ table[i] = null
+ end
+ end
+ table[color] = ft
+ end
+ tables[mclass] = table
end
+ return tables
+ end
- if current_rank == mtype.arguments.length - 1 then
- table[color] = mtype
- else
- var ft_table: Array[nullable Object]
- if color < table.length and table[color] != null then
- ft_table = table[color].as(Array[nullable Object])
- else
- ft_table = new Array[nullable Object]
+ private fun op(mask: Int, id:Int): Int is abstract
+ private fun phash(id: Int, mask: Int): Int do return op(mask, id)
+end
+
+class FTModPerfectHashing
+ super FTPerfectHashing
+ init(class_coloring: ClassColoring) do end
+ redef fun op(mask, id) do return mask % id
+end
+
+class FTAndPerfectHashing
+ super FTPerfectHashing
+ init(class_coloring: ClassColoring) do end
+ redef fun op(mask, id) do return mask.bin_and(id)
+end
+
+# live unanchored coloring
+class UnanchoredTypeColoring
+
+ private var coloration_result: Map[MType, Int] = new HashMap[MType, Int]
+ private var conflicts_graph: Map[MType, Set[MType]] = new HashMap[MType, Set[MType]]
+
+ init do end
+
+ fun colorize(elements: Map[MClassType, Set[MType]]): Map[MType, Int] do
+ build_conflicts_graph(elements)
+ colorize_elements(elements)
+ return coloration_result
+ end
+
+ fun build_tables(elements: Map[MClassType, Set[MType]]): Map[MClassType, Array[nullable MType]] do
+ var tables = new HashMap[MClassType, Array[nullable MType]]
+
+ for mclasstype, mtypes in elements do
+ var table = new Array[nullable MType]
+ for mtype in mtypes do
+ var color = self.coloration_result[mtype]
+ if table.length <= color then
+ for i in [table.length .. color[ do
+ table[i] = null
+ end
+ end
+ table[color] = mtype
end
- table[color] = ft_table
- build_livetype_table(mtype, current_rank + 1, ft_table, sizes)
+ tables[mclasstype] = table
end
+ return tables
end
# Colorize a collection of elements
- fun colorize_elements(elements: Collection[MType]) do
+ fun colorize_elements(elements: Map[MClassType, Set[MType]]) do
var min_color = 0
-
- for element in elements do
- var color = min_color
- while not self.is_color_free(element, color) do
- color += 1
+ for mclasstype, mclasstypes in elements do
+ for element in mclasstypes do
+ if self.coloration_result.has_key(element) then continue
+ var color = min_color
+ while not self.is_color_free(element, color) do
+ color += 1
+ end
+ coloration_result[element] = color
+ color = min_color
end
- coloration_result[element] = color
- color = min_color
end
end
return true
end
- # look for types in the same generic signatures
- private fun build_conflicts_graph(elements: Collection[MType]) do
- # regroup types by classes
- var genclasses = new HashMap[MClass, Set[MType]]
- for e in elements do
- if e isa MGenericType then
- if not genclasses.has_key(e.mclass) then
- genclasses[e.mclass] = new HashSet[MType]
- end
- genclasses[e.mclass].add(e)
- end
- end
-
- # for each class
- self.conflicts_graph_cache = new HashMap[MType, Set[MType]]
- for mclass, mtypes in genclasses do
- # for each rank
- for rank in [0..mclass.arity[ do
- # for each live type
- for mtype in mtypes do
- var mclasstype: MClassType
- if mtype isa MNullableType then
- mclasstype = mtype.mtype.as(MClassType)
- else
- mclasstype = mtype.as(MClassType)
- end
- var ft = mclasstype.arguments[rank]
- for otype in mtypes do
- if mtype == otype then continue
- var oclasstype: MClassType
- if otype isa MNullableType then
- oclasstype = otype.mtype.as(MClassType)
- else
- oclasstype = otype.as(MClassType)
- end
- var oft = oclasstype.arguments[rank]
- self.add_conflict(ft, oft)
- end
+ # look for unanchored types generated by the same type
+ private fun build_conflicts_graph(elements: Map[MClassType, Set[MType]]) do
+ for mclasstype, mtypes in elements do
+ for mtype in mtypes do
+ for otype in mtypes do
+ if otype == mtype then continue
+ self.add_conflict(mtype, otype)
end
end
end
private fun add_conflict(mtype: MType, otype: MType) do
if mtype == otype then return
- if not self.conflicts_graph_cache.has_key(mtype) then self.conflicts_graph_cache[mtype] = new HashSet[MClassType]
- self.conflicts_graph_cache[mtype].add(otype)
- if not self.conflicts_graph_cache.has_key(otype) then self.conflicts_graph_cache[otype] = new HashSet[MClassType]
- self.conflicts_graph_cache[otype].add(mtype)
+ if not self.conflicts_graph.has_key(mtype) then self.conflicts_graph[mtype] = new HashSet[MType]
+ self.conflicts_graph[mtype].add(otype)
+ if not self.conflicts_graph.has_key(otype) then self.conflicts_graph[otype] = new HashSet[MType]
+ self.conflicts_graph[otype].add(mtype)
end
- private fun conflicts_graph: Map[MType, Set[MType]] do return conflicts_graph_cache.as(not null)
end
-# Utils
+class NaiveUnanchoredTypeColoring
+ super UnanchoredTypeColoring
+
+ init do end
+
+ redef fun colorize_elements(elements: Map[MClassType, Set[MType]]) do
+ var color = 0
+ for mclasstype, mclasstypes in elements do
+ for element in mclasstypes do
+ coloration_result[element] = color
+ color += 1
+ end
+ end
+ end
+end
+
+abstract class UnanchoredTypePerfectHashing
+ super NaiveUnanchoredTypeColoring
+
+ private var masks: Map[MClassType, Int] = new HashMap[MClassType, Int]
+
+ init do end
+
+ redef fun colorize_elements(elements: Map[MClassType, Set[MType]]) do
+ var color = 1
+ for mclasstype, mclasstypes in elements do
+ for element in mclasstypes do
+ coloration_result[element] = color
+ color += 1
+ end
+ end
+ end
-# An ordered set
-private class OrderedSet[E]
- super Array[E]
+ fun compute_masks(elements: Map[MClassType, Set[MType]]): Map[MClassType, Int] do
+ for mclasstype, mtypes in elements do
+ self.masks[mclasstype] = compute_mask(mtypes)
+ end
+ return self.masks
+ end
- redef fun add(e) do
- if not self.has(e) then
- super(e)
+ private fun compute_mask(mtypes: Set[MType]): Int do
+ var mask = 0
+ loop
+ var used = new List[Int]
+ for mtype in mtypes do
+ var res = op(mask, self.coloration_result[mtype])
+ if used.has(res) then
+ break
+ else
+ used.add(res)
+ end
+ end
+ if used.length == mtypes.length then break
+ mask += 1
+ end
+ return mask
+ end
+
+ redef fun build_tables(elements: Map[MClassType, Set[MType]]): Map[MClassType, Array[nullable MType]] do
+ var tables = new HashMap[MClassType, Array[nullable MType]]
+
+ for mclasstype, mtypes in elements do
+ var table = new Array[nullable MType]
+ for mtype in mtypes do
+ var color = phash(self.coloration_result[mtype], masks[mclasstype])
+ if table.length <= color then
+ for i in [table.length .. color[ do
+ table[i] = null
+ end
+ end
+ table[color] = mtype
+ end
+ tables[mclasstype] = table
end
+ return tables
+ end
+
+ private fun op(mask: Int, id:Int): Int is abstract
+ private fun phash(id: Int, mask: Int): Int do return op(mask, id)
+end
+
+class UnanchoredTypeModPerfectHashing
+ super UnanchoredTypePerfectHashing
+ init do end
+ redef fun op(mask, id) do return mask % id
+end
+
+class UnanchoredTypeAndPerfectHashing
+ super UnanchoredTypePerfectHashing
+ init do end
+ redef fun op(mask, id) do return mask.bin_and(id)
+end
+
+
+# Utils
+
+redef class HashSet[E]
+ init from(elements: Collection[E]) do
+ init
+ self.add_all(elements)
+ end
+end
+
+redef class Array[E]
+ init from(elements: Collection[E]) do
+ init
+ self.add_all(elements)
end
- # Return a new OrderedSet with the elements only contened in 'self' and not in 'o'
- fun -(o: OrderedSet[E]): OrderedSet[E] do
- var res = new OrderedSet[E]
+ # Return a new Array with the elements only contened in 'self' and not in 'o'
+ fun -(o: Array[E]): Array[E] do
+ var res = new Array[E]
for e in self do if not o.has(e) then res.add(e)
return res
end
-end
\ No newline at end of file
+end
+
+redef class MModule
+
+ # Return a linearization of a set of mtypes
+ private fun linearize_mtypes(mtypes: Set[MType]): Array[MType] do
+ var lin = new Array[MType].from(mtypes)
+ var sorter = new TypeSorter(self)
+ sorter.sort(lin)
+ return lin
+ end
+
+ # Return a reverse linearization of a set of mtypes
+ private fun reverse_linearize_mtypes(mtypes: Set[MType]): Array[MType] do
+ var lin = new Array[MType].from(mtypes)
+ var sorter = new ReverseTypeSorter(self)
+ sorter.sort(lin)
+ return lin
+ end
+
+ # Return super types of a `mtype` in `self`
+ private fun super_mtypes(mtype: MType, mtypes: Set[MType]): Set[MType] do
+ if not self.super_mtypes_cache.has_key(mtype) then
+ var supers = new HashSet[MType]
+ for otype in mtypes do
+ if otype == mtype then continue
+ if mtype.is_subtype(self, null, otype) then
+ supers.add(otype)
+ end
+ end
+ self.super_mtypes_cache[mtype] = supers
+ end
+ return self.super_mtypes_cache[mtype]
+ end
+
+ private var super_mtypes_cache: Map[MType, Set[MType]] = new HashMap[MType, Set[MType]]
+
+ # Return all sub mtypes (directs and indirects) of a `mtype` in `self`
+ private fun sub_mtypes(mtype: MType, mtypes: Set[MType]): Set[MType] do
+ if not self.sub_mtypes_cache.has_key(mtype) then
+ var subs = new HashSet[MType]
+ for otype in mtypes do
+ if otype == mtype then continue
+ if otype.is_subtype(self, null, mtype) then
+ subs.add(otype)
+ end
+ end
+ self.sub_mtypes_cache[mtype] = subs
+ end
+ return self.sub_mtypes_cache[mtype]
+ end
+
+ private var sub_mtypes_cache: Map[MType, Set[MType]] = new HashMap[MType, Set[MType]]
+
+ # Return a linearization of a set of mclasses
+ private fun linearize_mclasses(mclasses: Set[MClass]): Array[MClass] do
+ var lin = new Array[MClass].from(mclasses)
+ var sorter = new ClassSorter(self)
+ sorter.sort(lin)
+ return lin
+ end
+
+ # Return a reverse linearization of a set of mtypes
+ private fun reverse_linearize_mclasses(mclasses: Set[MClass]): Array[MClass] do
+ var lin = new Array[MClass].from(mclasses)
+ var sorter = new ReverseClassSorter(self)
+ sorter.sort(lin)
+ return lin
+ end
+
+ # Return all super mclasses (directs and indirects) of a `mclass` in `self`
+ private fun super_mclasses(mclass: MClass): Set[MClass] do
+ if not self.super_mclasses_cache.has_key(mclass) then
+ var supers = new HashSet[MClass]
+ if self.flatten_mclass_hierarchy.has(mclass) then
+ for sup in self.flatten_mclass_hierarchy[mclass].greaters do
+ if sup == mclass then continue
+ supers.add(sup)
+ end
+ end
+ self.super_mclasses_cache[mclass] = supers
+ end
+ return self.super_mclasses_cache[mclass]
+ end
+
+ private var super_mclasses_cache: Map[MClass, Set[MClass]] = new HashMap[MClass, Set[MClass]]
+
+ # Return all parents of a `mclass` in `self`
+ private fun parent_mclasses(mclass: MClass): Set[MClass] do
+ if not self.parent_mclasses_cache.has_key(mclass) then
+ var parents = new HashSet[MClass]
+ if self.flatten_mclass_hierarchy.has(mclass) then
+ for sup in self.flatten_mclass_hierarchy[mclass].direct_greaters do
+ if sup == mclass then continue
+ parents.add(sup)
+ end
+ end
+ self.parent_mclasses_cache[mclass] = parents
+ end
+ return self.parent_mclasses_cache[mclass]
+ end
+
+ private var parent_mclasses_cache: Map[MClass, Set[MClass]] = new HashMap[MClass, Set[MClass]]
+
+ # Return all sub mclasses (directs and indirects) of a `mclass` in `self`
+ private fun sub_mclasses(mclass: MClass): Set[MClass] do
+ if not self.sub_mclasses_cache.has_key(mclass) then
+ var subs = new HashSet[MClass]
+ if self.flatten_mclass_hierarchy.has(mclass) then
+ for sub in self.flatten_mclass_hierarchy[mclass].smallers do
+ if sub == mclass then continue
+ subs.add(sub)
+ end
+ end
+ self.sub_mclasses_cache[mclass] = subs
+ end
+ return self.sub_mclasses_cache[mclass]
+ end
+
+ private var sub_mclasses_cache: Map[MClass, Set[MClass]] = new HashMap[MClass, Set[MClass]]
+
+ # All 'mproperties' associated to all 'mclassdefs' of `mclass`
+ private fun properties(mclass: MClass): Set[MProperty] do
+ if not self.properties_cache.has_key(mclass) then
+ var properties = new HashSet[MProperty]
+ var parents = self.super_mclasses(mclass)
+ for parent in parents do
+ properties.add_all(self.properties(parent))
+ end
+
+ for mclassdef in mclass.mclassdefs do
+ for mpropdef in mclassdef.mpropdefs do
+ properties.add(mpropdef.mproperty)
+ end
+ end
+ self.properties_cache[mclass] = properties
+ end
+ return properties_cache[mclass]
+ end
+
+ private var properties_cache: Map[MClass, Set[MProperty]] = new HashMap[MClass, Set[MProperty]]
+end
+
+# A sorter for linearize list of types
+class TypeSorter
+ super AbstractSorter[MType]
+
+ private var mmodule: MModule
+
+ init(mmodule: MModule) do self.mmodule = mmodule
+
+ redef fun compare(a, b) do
+ if a == b then
+ return 0
+ else if a.is_subtype(self.mmodule, null, b) then
+ return -1
+ end
+ return 1
+ end
+end
+
+# A sorter for reverse linearization
+class ReverseTypeSorter
+ super TypeSorter
+
+ init(mmodule: MModule) do end
+
+ redef fun compare(a, b) do
+ if a == b then
+ return 0
+ else if a.is_subtype(self.mmodule, null, b) then
+ return 1
+ end
+ return -1
+ end
+end
+
+# A sorter for linearize list of classes
+private class ClassSorter
+ super AbstractSorter[MClass]
+
+ var mmodule: MModule
+
+ redef fun compare(a, b) do
+ if a == b then
+ return 0
+ else if self.mmodule.flatten_mclass_hierarchy.has(a) and self.mmodule.flatten_mclass_hierarchy[a].greaters.has(b) then
+ return -1
+ end
+ return 1
+ end
+end
+
+# A sorter for reverse linearization
+private class ReverseClassSorter
+ super AbstractSorter[MClass]
+
+ var mmodule: MModule
+
+ redef fun compare(a, b) do
+ if a == b then
+ return 0
+ else if self.mmodule.flatten_mclass_hierarchy.has(a) and self.mmodule.flatten_mclass_hierarchy[a].greaters.has(b) then
+ return 1
+ end
+ return -1
+ end
+end
nitlanguage / nit.git / blobdiff