From f59f79da7d5b3bc3e839e13a2b125ac9321c6d72 Mon Sep 17 00:00:00 2001 From: Alexandre Terrasa Date: Tue, 5 Mar 2013 17:10:24 -0500 Subject: [PATCH] layout_builders: Introduce TypingHasher (for future refactoring) Signed-off-by: Alexandre Terrasa --- src/layout_builders.nit | 162 ++++++++++++++++++------------------- src/separate_compiler.nit | 4 +- src/separate_erasure_compiler.nit | 4 +- 3 files changed, 81 insertions(+), 89 deletions(-) diff --git a/src/layout_builders.nit b/src/layout_builders.nit index eb1ba32..105c52c 100644 --- a/src/layout_builders.nit +++ b/src/layout_builders.nit @@ -71,94 +71,15 @@ class CLTypingLayoutBuilder[E: Object] redef fun build_layout(elements) do return colorer.build_layout(elements) end -# Layout builder for MType using Perfect Hashing (PH) -class PHTypeLayoutBuilder - super TypingLayoutBuilder[MType] - - redef type LAYOUT: PHLayout[MType, MType] - - private var hasher: PerfectHasher[MType, MType] - private var mmodule: MModule - - init(mmodule: MModule, operator: PHOperator) do - self.mmodule = mmodule - self.hasher = new PerfectHasher[MType, MType](operator) - end - - 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 - 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 - private fun compute_ids(mtypes: Set[MType]): Map[MType, Int] 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 -end - -# Layout builder for MClass using Perfect Hashing (PH) -class PHClassLayoutBuilder - super TypingLayoutBuilder[MClass] - - redef type LAYOUT: PHLayout[MClass, MClass] +# Typing Layout builder using Perfect Hashing (PH) +class PHTypingLayoutBuilder[E: Object] + super TypingLayoutBuilder[E] - private var hasher: PerfectHasher[MClass, MClass] - private var mmodule: MModule + private var hasher: TypingHasher[E] - init(mmodule: MModule, operator: PHOperator) do - self.mmodule = mmodule - self.hasher = new PerfectHasher[MClass, MClass](operator) - end + init(hasher: TypingHasher[E]) do self.hasher = hasher - 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 - - # 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 - - # Ids start from 1 instead of 0 - private fun compute_ids(mclasses: Set[MClass]): Map[MClass, Int] 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 build_layout(elements) do return hasher.build_layout(elements) end abstract class PropertyLayoutBuilder[E: MProperty] @@ -759,3 +680,74 @@ class PHAndOperator init do end redef fun op(mask, id) do return mask.bin_and(id) end + +class TypingHasher[E: Object] + super PerfectHasher[E, E] + + var mmodule: MModule + + init(operator: PHOperator, mmodule: MModule) do + super(operator) + self.mmodule = mmodule + end + + 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 + +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 + +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 diff --git a/src/separate_compiler.nit b/src/separate_compiler.nit index 8b48676..474a27c 100644 --- a/src/separate_compiler.nit +++ b/src/separate_compiler.nit @@ -333,9 +333,9 @@ class SeparateCompiler if modelbuilder.toolcontext.opt_bm_typing.value then layout_builder = new BMTypingLayoutBuilder[MType](new MTypeBMizer(self.mainmodule)) else if modelbuilder.toolcontext.opt_phmod_typing.value then - layout_builder = new PHTypeLayoutBuilder(self.mainmodule, new PHModOperator) + layout_builder = new PHTypingLayoutBuilder[MType](new MTypeHasher(new PHModOperator, self.mainmodule)) else if modelbuilder.toolcontext.opt_phand_typing.value then - layout_builder = new PHTypeLayoutBuilder(self.mainmodule, new PHAndOperator) + layout_builder = new PHTypingLayoutBuilder[MType](new MTypeHasher(new PHAndOperator, self.mainmodule)) else layout_builder = new CLTypingLayoutBuilder[MType](new MTypeColorer(self.mainmodule)) end diff --git a/src/separate_erasure_compiler.nit b/src/separate_erasure_compiler.nit index 7e85d17..4590348 100644 --- a/src/separate_erasure_compiler.nit +++ b/src/separate_erasure_compiler.nit @@ -77,9 +77,9 @@ class SeparateErasureCompiler var layout_builder: TypingLayoutBuilder[MClass] if modelbuilder.toolcontext.opt_phmod_typing.value then - layout_builder = new PHClassLayoutBuilder(mainmodule, new PHModOperator) + layout_builder = new PHTypingLayoutBuilder[MClass](new MClassHasher(new PHModOperator, mainmodule)) else if modelbuilder.toolcontext.opt_phand_typing.value then - layout_builder = new PHClassLayoutBuilder(mainmodule, new PHAndOperator) + layout_builder = new PHTypingLayoutBuilder[MClass](new MClassHasher(new PHAndOperator, mainmodule)) else if modelbuilder.toolcontext.opt_bm_typing.value then layout_builder = new BMTypingLayoutBuilder[MClass](new MClassBMizer(mainmodule)) else -- 1.7.9.5