egraph-based midend: draw the rest of the owl (productionized). (#4953)
* egraph-based midend: draw the rest of the owl. * Rename `egg` submodule of cranelift-codegen to `egraph`. * Apply some feedback from @jsharp during code walkthrough. * Remove recursion from find_best_node by doing a single pass. Rather than recursively computing the lowest-cost node for a given eclass and memoizing the answer at each eclass node, we can do a single forward pass; because every eclass node refers only to earlier nodes, this is sufficient. The behavior may slightly differ from the earlier behavior because we cannot short-circuit costs to zero once a node is elaborated; but in practice this should not matter. * Make elaboration non-recursive. Use an explicit stack instead (with `ElabStackEntry` entries, alongside a result stack). * Make elaboration traversal of the domtree non-recursive/stack-safe. * Work analysis logic in Cranelift-side egraph glue into a general analysis framework in cranelift-egraph. * Apply static recursion limit to rule application. * Fix aarch64 wrt dynamic-vector support -- broken rebase. * Topo-sort cranelift-egraph before cranelift-codegen in publish script, like the comment instructs me to! * Fix multi-result call testcase. * Include `cranelift-egraph` in `PUBLISHED_CRATES`. * Fix atomic_rmw: not really a load. * Remove now-unnecessary PartialOrd/Ord derivations. * Address some code-review comments. * Review feedback. * Review feedback. * No overlap in mid-end rules, because we are defining a multi-constructor. * rustfmt * Review feedback. * Review feedback. * Review feedback. * Review feedback. * Remove redundant `mut`. * Add comment noting what rules can do. * Review feedback. * Clarify comment wording. * Update `has_memory_fence_semantics`. * Apply @jameysharp's improved loop-level computation. Co-authored-by: Jamey Sharp <jamey@minilop.net> * Fix suggestion commit. * Fix off-by-one in new loop-nest analysis. * Review feedback. * Review feedback. * Review feedback. * Use `Default`, not `std::default::Default`, as per @fitzgen Co-authored-by: Nick Fitzgerald <fitzgen@gmail.com> * Apply @fitzgen's comment elaboration to a doc-comment. Co-authored-by: Nick Fitzgerald <fitzgen@gmail.com> * Add stat for hitting the rewrite-depth limit. * Some code motion in split prelude to make the diff a little clearer wrt `main`. * Take @jameysharp's suggested `try_into()` usage for blockparam indices. Co-authored-by: Jamey Sharp <jamey@minilop.net> * Take @jameysharp's suggestion to avoid double-match on load op. Co-authored-by: Jamey Sharp <jamey@minilop.net> * Fix suggestion (add import). * Review feedback. * Fix stack_load handling. * Remove redundant can_store case. * Take @jameysharp's suggested improvement to FuncEGraph::build() logic Co-authored-by: Jamey Sharp <jamey@minilop.net> * Tweaks to FuncEGraph::build() on top of suggestion. * Take @jameysharp's suggested clarified condition Co-authored-by: Jamey Sharp <jamey@minilop.net> * Clean up after suggestion (unused variable). * Fix loop analysis. * loop level asserts * Revert constant-space loop analysis -- edge cases were incorrect, so let's go with the simple thing for now. * Take @jameysharp's suggestion re: result_tys Co-authored-by: Jamey Sharp <jamey@minilop.net> * Fix up after suggestion * Take @jameysharp's suggestion to use fold rather than reduce Co-authored-by: Jamey Sharp <jamey@minilop.net> * Fixup after suggestion * Take @jameysharp's suggestion to remove elaborate_eclass_use's return value. * Clarifying comment in terminator insts. Co-authored-by: Jamey Sharp <jamey@minilop.net> Co-authored-by: Nick Fitzgerald <fitzgen@gmail.com>
This commit is contained in:
Chris Fallin
@@ -6,25 +6,22 @@
|
||||
|
||||
use crate::fx::FxHashMap;
|
||||
use core::hash::Hash;
|
||||
use core::mem;
|
||||
use smallvec::{smallvec, SmallVec};
|
||||
|
||||
#[cfg(not(feature = "std"))]
|
||||
use crate::fx::FxHasher;
|
||||
#[cfg(not(feature = "std"))]
|
||||
type Hasher = core::hash::BuildHasherDefault<FxHasher>;
|
||||
|
||||
struct Val<K, V> {
|
||||
struct Val<V> {
|
||||
value: V,
|
||||
next_key: Option<K>,
|
||||
depth: usize,
|
||||
level: u32,
|
||||
generation: u32,
|
||||
}
|
||||
|
||||
/// A view into an occupied entry in a `ScopedHashMap`. It is part of the `Entry` enum.
|
||||
pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
|
||||
#[cfg(feature = "std")]
|
||||
entry: super::hash_map::OccupiedEntry<'a, K, Val<K, V>>,
|
||||
#[cfg(not(feature = "std"))]
|
||||
entry: super::hash_map::OccupiedEntry<'a, K, Val<K, V>, Hasher>,
|
||||
entry: super::hash_map::OccupiedEntry<'a, K, Val<V>>,
|
||||
}
|
||||
|
||||
impl<'a, K, V> OccupiedEntry<'a, K, V> {
|
||||
@@ -36,22 +33,34 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> {
|
||||
|
||||
/// A view into a vacant entry in a `ScopedHashMap`. It is part of the `Entry` enum.
|
||||
pub struct VacantEntry<'a, K: 'a, V: 'a> {
|
||||
#[cfg(feature = "std")]
|
||||
entry: super::hash_map::VacantEntry<'a, K, Val<K, V>>,
|
||||
#[cfg(not(feature = "std"))]
|
||||
entry: super::hash_map::VacantEntry<'a, K, Val<K, V>, Hasher>,
|
||||
next_key: Option<K>,
|
||||
depth: usize,
|
||||
entry: InsertLoc<'a, K, V>,
|
||||
depth: u32,
|
||||
generation: u32,
|
||||
}
|
||||
|
||||
impl<'a, K: Hash, V> VacantEntry<'a, K, V> {
|
||||
/// Where to insert from a `VacantEntry`. May be vacant or occupied in
|
||||
/// the underlying map because of lazy (generation-based) deletion.
|
||||
enum InsertLoc<'a, K: 'a, V: 'a> {
|
||||
Vacant(super::hash_map::VacantEntry<'a, K, Val<V>>),
|
||||
Occupied(super::hash_map::OccupiedEntry<'a, K, Val<V>>),
|
||||
}
|
||||
|
||||
impl<'a, K, V> VacantEntry<'a, K, V> {
|
||||
/// Sets the value of the entry with the `VacantEntry`'s key.
|
||||
pub fn insert(self, value: V) {
|
||||
self.entry.insert(Val {
|
||||
let val = Val {
|
||||
value,
|
||||
next_key: self.next_key,
|
||||
depth: self.depth,
|
||||
});
|
||||
level: self.depth,
|
||||
generation: self.generation,
|
||||
};
|
||||
match self.entry {
|
||||
InsertLoc::Vacant(v) => {
|
||||
v.insert(val);
|
||||
}
|
||||
InsertLoc::Occupied(mut o) => {
|
||||
o.insert(val);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -69,9 +78,9 @@ pub enum Entry<'a, K: 'a, V: 'a> {
|
||||
/// Shadowing, where one scope has entries with the same keys as a containing scope,
|
||||
/// is not supported in this implementation.
|
||||
pub struct ScopedHashMap<K, V> {
|
||||
map: FxHashMap<K, Val<K, V>>,
|
||||
last_insert: Option<K>,
|
||||
current_depth: usize,
|
||||
map: FxHashMap<K, Val<V>>,
|
||||
generation_by_depth: SmallVec<[u32; 8]>,
|
||||
generation: u32,
|
||||
}
|
||||
|
||||
impl<K, V> ScopedHashMap<K, V>
|
||||
@@ -82,52 +91,115 @@ where
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
map: FxHashMap(),
|
||||
last_insert: None,
|
||||
current_depth: 0,
|
||||
generation: 0,
|
||||
generation_by_depth: smallvec![0],
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates an empty `ScopedHashMap` with some pre-allocated capacity.
|
||||
pub fn with_capacity(cap: usize) -> Self {
|
||||
let mut map = FxHashMap::default();
|
||||
map.reserve(cap);
|
||||
Self {
|
||||
map,
|
||||
generation: 0,
|
||||
generation_by_depth: smallvec![0],
|
||||
}
|
||||
}
|
||||
|
||||
/// Similar to `FxHashMap::entry`, gets the given key's corresponding entry in the map for
|
||||
/// in-place manipulation.
|
||||
pub fn entry(&mut self, key: K) -> Entry<K, V> {
|
||||
pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V> {
|
||||
self.entry_with_depth(key, self.depth())
|
||||
}
|
||||
|
||||
/// Get the entry, setting the scope depth at which to insert.
|
||||
pub fn entry_with_depth<'a>(&'a mut self, key: K, depth: usize) -> Entry<'a, K, V> {
|
||||
debug_assert!(depth <= self.generation_by_depth.len());
|
||||
let generation = self.generation_by_depth[depth];
|
||||
let depth = depth as u32;
|
||||
use super::hash_map::Entry::*;
|
||||
match self.map.entry(key) {
|
||||
Occupied(entry) => Entry::Occupied(OccupiedEntry { entry }),
|
||||
Vacant(entry) => {
|
||||
let clone_key = entry.key().clone();
|
||||
Entry::Vacant(VacantEntry {
|
||||
entry,
|
||||
next_key: mem::replace(&mut self.last_insert, Some(clone_key)),
|
||||
depth: self.current_depth,
|
||||
})
|
||||
Occupied(entry) => {
|
||||
let entry_generation = entry.get().generation;
|
||||
let entry_depth = entry.get().level as usize;
|
||||
if self.generation_by_depth.get(entry_depth).cloned() == Some(entry_generation) {
|
||||
Entry::Occupied(OccupiedEntry { entry })
|
||||
} else {
|
||||
Entry::Vacant(VacantEntry {
|
||||
entry: InsertLoc::Occupied(entry),
|
||||
depth,
|
||||
generation,
|
||||
})
|
||||
}
|
||||
}
|
||||
Vacant(entry) => Entry::Vacant(VacantEntry {
|
||||
entry: InsertLoc::Vacant(entry),
|
||||
depth,
|
||||
generation,
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get a value from a key, if present.
|
||||
pub fn get<'a>(&'a self, key: &K) -> Option<&'a V> {
|
||||
self.map
|
||||
.get(key)
|
||||
.filter(|entry| {
|
||||
let level = entry.level as usize;
|
||||
self.generation_by_depth.get(level).cloned() == Some(entry.generation)
|
||||
})
|
||||
.map(|entry| &entry.value)
|
||||
}
|
||||
|
||||
/// Insert a key-value pair if absent. No-op if already exists.
|
||||
pub fn insert_if_absent(&mut self, key: K, value: V) {
|
||||
self.insert_if_absent_with_depth(key, value, self.depth());
|
||||
}
|
||||
|
||||
/// Insert a key-value pair if absent, using the given depth for
|
||||
/// the insertion. No-op if already exists.
|
||||
pub fn insert_if_absent_with_depth(&mut self, key: K, value: V, depth: usize) {
|
||||
match self.entry_with_depth(key, depth) {
|
||||
Entry::Vacant(v) => {
|
||||
v.insert(value);
|
||||
}
|
||||
Entry::Occupied(_) => {
|
||||
// Nothing.
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Enter a new scope.
|
||||
pub fn increment_depth(&mut self) {
|
||||
// Increment the depth.
|
||||
self.current_depth = self.current_depth.checked_add(1).unwrap();
|
||||
self.generation_by_depth.push(self.generation);
|
||||
}
|
||||
|
||||
/// Exit the current scope.
|
||||
pub fn decrement_depth(&mut self) {
|
||||
// Remove all elements inserted at the current depth.
|
||||
while let Some(key) = self.last_insert.clone() {
|
||||
use crate::hash_map::Entry::*;
|
||||
match self.map.entry(key) {
|
||||
Occupied(entry) => {
|
||||
if entry.get().depth != self.current_depth {
|
||||
break;
|
||||
}
|
||||
self.last_insert = entry.remove_entry().1.next_key;
|
||||
}
|
||||
Vacant(_) => panic!(),
|
||||
}
|
||||
}
|
||||
self.generation += 1;
|
||||
self.generation_by_depth.pop();
|
||||
}
|
||||
|
||||
// Decrement the depth.
|
||||
self.current_depth = self.current_depth.checked_sub(1).unwrap();
|
||||
/// Return the current scope depth.
|
||||
pub fn depth(&self) -> usize {
|
||||
self.generation_by_depth
|
||||
.len()
|
||||
.checked_sub(1)
|
||||
.expect("generation_by_depth cannot be empty")
|
||||
}
|
||||
|
||||
/// Remote an entry.
|
||||
pub fn remove(&mut self, key: &K) -> Option<V> {
|
||||
self.map.remove(key).and_then(|val| {
|
||||
let entry_generation = val.generation;
|
||||
let entry_depth = val.level as usize;
|
||||
if self.generation_by_depth.get(entry_depth).cloned() == Some(entry_generation) {
|
||||
Some(val.value)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -230,4 +302,22 @@ mod tests {
|
||||
Entry::Vacant(entry) => entry.insert(3),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn insert_arbitrary_depth() {
|
||||
let mut map: ScopedHashMap<i32, i32> = ScopedHashMap::new();
|
||||
map.insert_if_absent(1, 2);
|
||||
assert_eq!(map.get(&1), Some(&2));
|
||||
map.increment_depth();
|
||||
assert_eq!(map.get(&1), Some(&2));
|
||||
map.insert_if_absent(3, 4);
|
||||
assert_eq!(map.get(&3), Some(&4));
|
||||
map.decrement_depth();
|
||||
assert_eq!(map.get(&3), None);
|
||||
map.increment_depth();
|
||||
map.insert_if_absent_with_depth(3, 4, 0);
|
||||
assert_eq!(map.get(&3), Some(&4));
|
||||
map.decrement_depth();
|
||||
assert_eq!(map.get(&3), Some(&4));
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user